feat: add note mode and workflow config
This commit is contained in:
shiyue
94
.cursor/agents/trellis-check.md
Normal file
94
.cursor/agents/trellis-check.md
Normal file
@@ -0,0 +1,94 @@
|
||||
---
|
||||
name: trellis-check
|
||||
description: |
|
||||
Code quality check expert. Reviews code changes against specs and self-fixes issues.
|
||||
tools: Read, Write, Edit, Bash, Glob, Grep, mcp__exa__web_search_exa, mcp__exa__get_code_context_exa
|
||||
---
|
||||
# Check Agent
|
||||
|
||||
You are the Check Agent in the Trellis workflow.
|
||||
|
||||
## Context
|
||||
|
||||
Before checking, read:
|
||||
- `.trellis/spec/` - Development guidelines
|
||||
- Pre-commit checklist for quality standards
|
||||
|
||||
## Core Responsibilities
|
||||
|
||||
1. **Get code changes** - Use git diff to get uncommitted code
|
||||
2. **Check against specs** - Verify code follows guidelines
|
||||
3. **Self-fix** - Fix issues yourself, not just report them
|
||||
4. **Run verification** - typecheck and lint
|
||||
|
||||
## Important
|
||||
|
||||
**Fix issues yourself**, don't just report them.
|
||||
|
||||
You have write and edit tools, you can modify code directly.
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
### Step 1: Get Changes
|
||||
|
||||
```bash
|
||||
git diff --name-only # List changed files
|
||||
git diff # View specific changes
|
||||
```
|
||||
|
||||
### Step 2: Check Against Specs
|
||||
|
||||
Read relevant specs in `.trellis/spec/` to check code:
|
||||
|
||||
- Does it follow directory structure conventions
|
||||
- Does it follow naming conventions
|
||||
- Does it follow code patterns
|
||||
- Are there missing types
|
||||
- Are there potential bugs
|
||||
|
||||
### Step 3: Self-Fix
|
||||
|
||||
After finding issues:
|
||||
|
||||
1. Fix the issue directly (use edit tool)
|
||||
2. Record what was fixed
|
||||
3. Continue checking other issues
|
||||
|
||||
### Step 4: Run Verification
|
||||
|
||||
Run project's lint and typecheck commands to verify changes.
|
||||
|
||||
If failed, fix issues and re-run.
|
||||
|
||||
---
|
||||
|
||||
## Report Format
|
||||
|
||||
```markdown
|
||||
## Self-Check Complete
|
||||
|
||||
### Files Checked
|
||||
|
||||
- src/components/Feature.tsx
|
||||
- src/hooks/useFeature.ts
|
||||
|
||||
### Issues Found and Fixed
|
||||
|
||||
1. `<file>:<line>` - <what was fixed>
|
||||
2. `<file>:<line>` - <what was fixed>
|
||||
|
||||
### Issues Not Fixed
|
||||
|
||||
(If there are issues that cannot be self-fixed, list them here with reasons)
|
||||
|
||||
### Verification Results
|
||||
|
||||
- TypeCheck: Passed
|
||||
- Lint: Passed
|
||||
|
||||
### Summary
|
||||
|
||||
Checked X files, found Y issues, all fixed.
|
||||
```
|
||||
94
.cursor/agents/trellis-implement.md
Normal file
94
.cursor/agents/trellis-implement.md
Normal file
@@ -0,0 +1,94 @@
|
||||
---
|
||||
name: trellis-implement
|
||||
description: |
|
||||
Code implementation expert. Understands specs and requirements, then implements features. No git commit allowed.
|
||||
tools: Read, Write, Edit, Bash, Glob, Grep, mcp__exa__web_search_exa, mcp__exa__get_code_context_exa
|
||||
---
|
||||
# Implement Agent
|
||||
|
||||
You are the Implement Agent in the Trellis workflow.
|
||||
|
||||
## Context
|
||||
|
||||
Before implementing, read:
|
||||
- `.trellis/workflow.md` - Project workflow
|
||||
- `.trellis/spec/` - Development guidelines
|
||||
- Task `prd.md` - Requirements document
|
||||
- Task `info.md` - Technical design (if exists)
|
||||
|
||||
## Core Responsibilities
|
||||
|
||||
1. **Understand specs** - Read relevant spec files in `.trellis/spec/`
|
||||
2. **Understand requirements** - Read prd.md and info.md
|
||||
3. **Implement features** - Write code following specs and design
|
||||
4. **Self-check** - Ensure code quality
|
||||
5. **Report results** - Report completion status
|
||||
|
||||
## Forbidden Operations
|
||||
|
||||
**Do NOT execute these git commands:**
|
||||
|
||||
- `git commit`
|
||||
- `git push`
|
||||
- `git merge`
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
### 1. Understand Specs
|
||||
|
||||
Read relevant specs based on task type:
|
||||
|
||||
- Spec layers: `.trellis/spec/<package>/<layer>/`
|
||||
- Shared guides: `.trellis/spec/guides/`
|
||||
|
||||
### 2. Understand Requirements
|
||||
|
||||
Read the task's prd.md and info.md:
|
||||
|
||||
- What are the core requirements
|
||||
- Key points of technical design
|
||||
- Which files to modify/create
|
||||
|
||||
### 3. Implement Features
|
||||
|
||||
- Write code following specs and technical design
|
||||
- Follow existing code patterns
|
||||
- Only do what's required, no over-engineering
|
||||
|
||||
### 4. Verify
|
||||
|
||||
Run project's lint and typecheck commands to verify changes.
|
||||
|
||||
---
|
||||
|
||||
## Report Format
|
||||
|
||||
```markdown
|
||||
## Implementation Complete
|
||||
|
||||
### Files Modified
|
||||
|
||||
- `src/components/Feature.tsx` - New component
|
||||
- `src/hooks/useFeature.ts` - New hook
|
||||
|
||||
### Implementation Summary
|
||||
|
||||
1. Created Feature component...
|
||||
2. Added useFeature hook...
|
||||
|
||||
### Verification Results
|
||||
|
||||
- Lint: Passed
|
||||
- TypeCheck: Passed
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Code Standards
|
||||
|
||||
- Follow existing code patterns
|
||||
- Don't add unnecessary abstractions
|
||||
- Only do what's required, no over-engineering
|
||||
- Keep code readable
|
||||
137
.cursor/agents/trellis-research.md
Normal file
137
.cursor/agents/trellis-research.md
Normal file
@@ -0,0 +1,137 @@
|
||||
---
|
||||
name: trellis-research
|
||||
description: |
|
||||
Code and tech search expert. Finds files, patterns, and tech solutions, and PERSISTS every finding to the current task's research/ directory. No code modifications outside that directory.
|
||||
tools: Read, Write, Glob, Grep, Bash, mcp__exa__web_search_exa, mcp__exa__get_code_context_exa, Skill, mcp__chrome-devtools__*
|
||||
---
|
||||
# Research Agent
|
||||
|
||||
You are the Research Agent in the Trellis workflow.
|
||||
|
||||
## Core Principle
|
||||
|
||||
**You do one thing: find, explain, and PERSIST information.**
|
||||
|
||||
Conversations get compacted; files don't. Every research output MUST end up as a file under `{TASK_DIR}/research/`. Returning findings only through the chat reply is a failure — the caller cannot read them next session.
|
||||
|
||||
---
|
||||
|
||||
## Core Responsibilities
|
||||
|
||||
1. **Internal Search** — locate files/components, understand code logic, discover patterns (Glob, Grep, Read)
|
||||
2. **External Search** — library docs, API references, best practices (web search)
|
||||
3. **Persist** — write each research topic to `{TASK_DIR}/research/<topic>.md`
|
||||
4. **Report** — return file paths + one-line summaries to the main agent (not full content)
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
### Step 1: Resolve Current Task
|
||||
|
||||
Read `.trellis/.current-task` → task directory (e.g. `.trellis/tasks/04-17-foo/`). If empty or missing, ask the user where to write output; do NOT guess.
|
||||
|
||||
Ensure `{TASK_DIR}/research/` exists:
|
||||
|
||||
```bash
|
||||
mkdir -p <TASK_DIR>/research
|
||||
```
|
||||
|
||||
### Step 2: Understand Search Request
|
||||
|
||||
Classify: internal / external / mixed. Determine scope (global / specific directory) and expected shape (file list / pattern notes / tech comparison).
|
||||
|
||||
### Step 3: Execute Search
|
||||
|
||||
Run independent searches in parallel (Glob + Grep + web) for efficiency.
|
||||
|
||||
### Step 4: Persist Each Topic
|
||||
|
||||
For each distinct research topic, Write a markdown file at `{TASK_DIR}/research/<topic-slug>.md`. Use the File Format below.
|
||||
|
||||
### Step 5: Report to Main Agent
|
||||
|
||||
Reply with ONLY:
|
||||
|
||||
- List of files written (paths relative to repo root)
|
||||
- One-line summary per file
|
||||
- Any critical caveats that the main agent needs to know right now
|
||||
|
||||
Do NOT paste full research content into the reply. The files are the contract.
|
||||
|
||||
---
|
||||
|
||||
## Scope Limits (Strict)
|
||||
|
||||
### Write ALLOWED
|
||||
|
||||
- `{TASK_DIR}/research/*.md` — your own output
|
||||
- Creating `{TASK_DIR}/research/` if it doesn't exist (via `mkdir -p`)
|
||||
|
||||
### Write FORBIDDEN
|
||||
|
||||
- Code files (`src/`, `lib/`, …)
|
||||
- Spec files (`.trellis/spec/`) — main agent should use `update-spec` skill instead
|
||||
- `.trellis/scripts/`, `.trellis/workflow.md`, platform config (`.claude/`, `.cursor/`, etc.)
|
||||
- Other task directories
|
||||
- Any git operation (commit / push / branch / merge)
|
||||
|
||||
If the user asks you to edit code, decline and suggest spawning `implement` instead.
|
||||
|
||||
---
|
||||
|
||||
## File Format
|
||||
|
||||
Each `{TASK_DIR}/research/<topic>.md` should follow:
|
||||
|
||||
```markdown
|
||||
# Research: <topic>
|
||||
|
||||
- **Query**: <original query>
|
||||
- **Scope**: <internal / external / mixed>
|
||||
- **Date**: <YYYY-MM-DD>
|
||||
|
||||
## Findings
|
||||
|
||||
### Files Found
|
||||
|
||||
| File Path | Description |
|
||||
|---|---|
|
||||
| `src/services/xxx.ts` | Main implementation |
|
||||
| `src/types/xxx.ts` | Type definitions |
|
||||
|
||||
### Code Patterns
|
||||
|
||||
<describe patterns, cite file:line>
|
||||
|
||||
### External References
|
||||
|
||||
- [Library X docs](url) — <why relevant, version constraints>
|
||||
|
||||
### Related Specs
|
||||
|
||||
- `.trellis/spec/xxx.md` — <description>
|
||||
|
||||
## Caveats / Not Found
|
||||
|
||||
<anything incomplete or uncertain>
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Guidelines
|
||||
|
||||
### DO
|
||||
|
||||
- Provide specific file paths and line numbers
|
||||
- Quote actual code snippets
|
||||
- Persist every topic to its own file
|
||||
- Return file paths in your reply, not the full content
|
||||
- Mark "not found" explicitly when searches come up empty
|
||||
|
||||
### DON'T
|
||||
|
||||
- Don't write code or modify files outside `{TASK_DIR}/research/`
|
||||
- Don't guess uncertain info
|
||||
- Don't paste full research text into the reply (files are the deliverable)
|
||||
- Don't propose improvements or critique implementation (that's not your role)
|
||||
51
.cursor/commands/trellis-continue.md
Normal file
51
.cursor/commands/trellis-continue.md
Normal file
@@ -0,0 +1,51 @@
|
||||
# Continue Current Task
|
||||
|
||||
Resume work on the current task — pick up at the right phase/step in `.trellis/workflow.md`.
|
||||
|
||||
---
|
||||
|
||||
## Step 1: Load Current Context
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/get_context.py
|
||||
```
|
||||
|
||||
Confirms: current task, git state, recent commits.
|
||||
|
||||
## Step 2: Load the Phase Index
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/get_context.py --mode phase
|
||||
```
|
||||
|
||||
Shows the Phase Index (Plan / Execute / Finish) with routing + skill mapping.
|
||||
|
||||
## Step 3: Decide Where You Are
|
||||
|
||||
Compare the task's `prd.md` + recent activity against the Phase Index:
|
||||
|
||||
- No `prd.md` yet, or requirements unclear → **Phase 1: Plan** (start at step 1.0/1.1)
|
||||
- `prd.md` exists + context configured, but code not written → **Phase 2: Execute** (step 2.1)
|
||||
- Code written, pending final quality gate → **Phase 3: Finish** (step 3.1)
|
||||
|
||||
Phase rules (full detail in `.trellis/workflow.md`):
|
||||
|
||||
1. Run steps **in order** within a phase — `[required]` steps must not be skipped
|
||||
2. `[once]` steps are already done if the output exists (e.g., `prd.md` for 1.1; `implement.jsonl` with curated entries for 1.3) — skip them
|
||||
3. You may go back to an earlier phase if discoveries require it
|
||||
|
||||
## Step 4: Load the Specific Step
|
||||
|
||||
Once you know which step to resume at:
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/get_context.py --mode phase --step <X.X> --platform cursor
|
||||
```
|
||||
|
||||
Follow the loaded instructions. After each `[required]` step completes, move to the next.
|
||||
|
||||
---
|
||||
|
||||
## Reference
|
||||
|
||||
Full workflow, skill routing table, and the DO-NOT-skip table live in `.trellis/workflow.md`. This command is only an entry point — the canonical guidance is there.
|
||||
32
.cursor/commands/trellis-finish-work.md
Normal file
32
.cursor/commands/trellis-finish-work.md
Normal file
@@ -0,0 +1,32 @@
|
||||
# Finish Work
|
||||
|
||||
Wrap up the current session.
|
||||
|
||||
## Step 1: Quality Gate
|
||||
|
||||
`trellis-check` should have already run in Phase 3. If not, trigger it now and do not proceed until lint, type-check, tests, and spec compliance pass.
|
||||
|
||||
## Step 2: Remind User to Commit
|
||||
|
||||
If there are uncommitted changes:
|
||||
|
||||
> "Please review the changes and commit when ready."
|
||||
|
||||
Do NOT run `git commit` — the human commits after testing.
|
||||
|
||||
## Step 3: Record Session (after commit)
|
||||
|
||||
Archive finished tasks (judge by work status, not the `status` field):
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/task.py archive <task-name>
|
||||
```
|
||||
|
||||
Append a session entry (auto-handles journal rotation, line count, index update):
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/add_session.py \
|
||||
--title "Session Title" \
|
||||
--commit "hash1,hash2" \
|
||||
--summary "Brief summary"
|
||||
```
|
||||
24
.cursor/hooks.json
Normal file
24
.cursor/hooks.json
Normal file
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"version": 1,
|
||||
"hooks": {
|
||||
"preToolUse": [
|
||||
{
|
||||
"command": "python3 .cursor/hooks/inject-subagent-context.py",
|
||||
"matcher": "Task",
|
||||
"timeout": 30
|
||||
}
|
||||
],
|
||||
"sessionStart": [
|
||||
{
|
||||
"command": "python3 .cursor/hooks/session-start.py",
|
||||
"timeout": 10
|
||||
}
|
||||
],
|
||||
"beforeSubmitPrompt": [
|
||||
{
|
||||
"command": "python3 .cursor/hooks/inject-workflow-state.py",
|
||||
"timeout": 5
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
641
.cursor/hooks/inject-subagent-context.py
Normal file
641
.cursor/hooks/inject-subagent-context.py
Normal file
@@ -0,0 +1,641 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Multi-Platform Sub-Agent Context Injection Hook
|
||||
|
||||
Injects task-specific context when sub-agents (implement, check, research) are spawned.
|
||||
|
||||
Core Design Philosophy:
|
||||
- Hook is responsible for injecting all context, subagent works autonomously with complete info
|
||||
- Each agent has a dedicated jsonl file defining its context
|
||||
- No resume needed, no segmentation, behavior controlled by code not prompt
|
||||
|
||||
Trigger: PreToolUse (before Task tool call)
|
||||
|
||||
Context Source: .trellis/.current-task points to task directory
|
||||
- implement.jsonl - Implement agent dedicated context
|
||||
- check.jsonl - Check agent dedicated context
|
||||
- prd.md - Requirements document
|
||||
- info.md - Technical design
|
||||
- codex-review-output.txt - Code Review results
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
# IMPORTANT: Suppress all warnings FIRST
|
||||
import warnings
|
||||
warnings.filterwarnings("ignore")
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
# IMPORTANT: Force stdout to use UTF-8 on Windows
|
||||
# This fixes UnicodeEncodeError when outputting non-ASCII characters
|
||||
if sys.platform.startswith("win"):
|
||||
import io as _io
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8", errors="replace") # type: ignore[union-attr]
|
||||
elif hasattr(sys.stdout, "detach"):
|
||||
sys.stdout = _io.TextIOWrapper(sys.stdout.detach(), encoding="utf-8", errors="replace") # type: ignore[union-attr]
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# Path Constants (change here to rename directories)
|
||||
# =============================================================================
|
||||
|
||||
DIR_WORKFLOW = ".trellis"
|
||||
DIR_SPEC = "spec"
|
||||
FILE_CURRENT_TASK = ".current-task"
|
||||
FILE_TASK_JSON = "task.json"
|
||||
|
||||
# =============================================================================
|
||||
# Subagent Constants (change here to rename subagent types)
|
||||
# =============================================================================
|
||||
|
||||
AGENT_IMPLEMENT = "trellis-implement"
|
||||
AGENT_CHECK = "trellis-check"
|
||||
AGENT_RESEARCH = "trellis-research"
|
||||
|
||||
# Agents that require a task directory
|
||||
AGENTS_REQUIRE_TASK = (AGENT_IMPLEMENT, AGENT_CHECK)
|
||||
# All supported agents
|
||||
AGENTS_ALL = (AGENT_IMPLEMENT, AGENT_CHECK, AGENT_RESEARCH)
|
||||
|
||||
|
||||
def find_repo_root(start_path: str) -> str | None:
|
||||
"""
|
||||
Find git repo root from start_path upwards
|
||||
|
||||
Returns:
|
||||
Repo root path, or None if not found
|
||||
"""
|
||||
current = Path(start_path).resolve()
|
||||
while current != current.parent:
|
||||
if (current / ".git").exists():
|
||||
return str(current)
|
||||
current = current.parent
|
||||
return None
|
||||
|
||||
|
||||
def get_current_task(repo_root: str) -> str | None:
|
||||
"""
|
||||
Read current task directory path from .trellis/.current-task
|
||||
|
||||
Returns:
|
||||
Task directory relative path (relative to repo_root)
|
||||
None if not set
|
||||
"""
|
||||
current_task_file = os.path.join(repo_root, DIR_WORKFLOW, FILE_CURRENT_TASK)
|
||||
if not os.path.exists(current_task_file):
|
||||
return None
|
||||
|
||||
try:
|
||||
with open(current_task_file, "r", encoding="utf-8") as f:
|
||||
content = f.read().strip()
|
||||
if not content:
|
||||
return None
|
||||
normalized = content.replace("\\", "/")
|
||||
while normalized.startswith("./"):
|
||||
normalized = normalized[2:]
|
||||
if normalized.startswith("tasks/"):
|
||||
normalized = f".trellis/{normalized}"
|
||||
return normalized
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def read_file_content(base_path: str, file_path: str) -> str | None:
|
||||
"""Read file content, return None if file doesn't exist"""
|
||||
full_path = os.path.join(base_path, file_path)
|
||||
if os.path.exists(full_path) and os.path.isfile(full_path):
|
||||
try:
|
||||
with open(full_path, "r", encoding="utf-8") as f:
|
||||
return f.read()
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def read_directory_contents(
|
||||
base_path: str, dir_path: str, max_files: int = 20
|
||||
) -> list[tuple[str, str]]:
|
||||
"""
|
||||
Read all .md files in a directory
|
||||
|
||||
Args:
|
||||
base_path: Base path (usually repo_root)
|
||||
dir_path: Directory relative path
|
||||
max_files: Max files to read (prevent huge directories)
|
||||
|
||||
Returns:
|
||||
[(file_path, content), ...]
|
||||
"""
|
||||
full_path = os.path.join(base_path, dir_path)
|
||||
if not os.path.exists(full_path) or not os.path.isdir(full_path):
|
||||
return []
|
||||
|
||||
results = []
|
||||
try:
|
||||
# Only read .md files, sorted by filename
|
||||
md_files = sorted(
|
||||
[
|
||||
f
|
||||
for f in os.listdir(full_path)
|
||||
if f.endswith(".md") and os.path.isfile(os.path.join(full_path, f))
|
||||
]
|
||||
)
|
||||
|
||||
for filename in md_files[:max_files]:
|
||||
file_full_path = os.path.join(full_path, filename)
|
||||
relative_path = os.path.join(dir_path, filename)
|
||||
try:
|
||||
with open(file_full_path, "r", encoding="utf-8") as f:
|
||||
content = f.read()
|
||||
results.append((relative_path, content))
|
||||
except Exception:
|
||||
continue
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def read_jsonl_entries(base_path: str, jsonl_path: str) -> list[tuple[str, str]]:
|
||||
"""
|
||||
Read all file/directory contents referenced in jsonl file
|
||||
|
||||
Schema:
|
||||
{"file": "path/to/file.md", "reason": "..."}
|
||||
{"file": "path/to/dir/", "type": "directory", "reason": "..."}
|
||||
{"_example": "..."} # seed row — skipped (no `file` field)
|
||||
|
||||
Rows without a ``file`` field (e.g. the self-describing seed line written
|
||||
by ``task.py create`` before the agent has curated entries) are skipped
|
||||
silently. If the resulting entry list is empty, a stderr warning is
|
||||
emitted so the operator can debug missing context.
|
||||
|
||||
Returns:
|
||||
[(path, content), ...]
|
||||
"""
|
||||
full_path = os.path.join(base_path, jsonl_path)
|
||||
if not os.path.exists(full_path):
|
||||
print(
|
||||
f"[inject-subagent-context] WARN: {jsonl_path} not found — "
|
||||
f"sub-agent will receive only prd.md",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return []
|
||||
|
||||
results = []
|
||||
saw_real_entry = False
|
||||
try:
|
||||
with open(full_path, "r", encoding="utf-8") as f:
|
||||
for line in f:
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
try:
|
||||
item = json.loads(line)
|
||||
file_path = item.get("file") or item.get("path")
|
||||
entry_type = item.get("type", "file")
|
||||
|
||||
if not file_path:
|
||||
# Seed / comment row — skip silently
|
||||
continue
|
||||
|
||||
saw_real_entry = True
|
||||
if entry_type == "directory":
|
||||
# Read all .md files in directory
|
||||
dir_contents = read_directory_contents(base_path, file_path)
|
||||
results.extend(dir_contents)
|
||||
else:
|
||||
# Read single file
|
||||
content = read_file_content(base_path, file_path)
|
||||
if content:
|
||||
results.append((file_path, content))
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not saw_real_entry:
|
||||
print(
|
||||
f"[inject-subagent-context] WARN: {jsonl_path} has no curated "
|
||||
f"entries (only seed / empty) — sub-agent will receive only "
|
||||
f"prd.md. See workflow.md Phase 1.3 for curation guidance.",
|
||||
file=sys.stderr,
|
||||
)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
|
||||
|
||||
def get_agent_context(repo_root: str, task_dir: str, agent_type: str) -> str:
|
||||
"""
|
||||
Get context from {agent_type}.jsonl for the specified agent.
|
||||
Only reads implement.jsonl or check.jsonl (the two JSONL files the task system creates).
|
||||
"""
|
||||
context_parts = []
|
||||
|
||||
agent_jsonl = f"{task_dir}/{agent_type}.jsonl"
|
||||
for file_path, content in read_jsonl_entries(repo_root, agent_jsonl):
|
||||
context_parts.append(f"=== {file_path} ===\n{content}")
|
||||
|
||||
return "\n\n".join(context_parts)
|
||||
|
||||
|
||||
def get_implement_context(repo_root: str, task_dir: str) -> str:
|
||||
"""
|
||||
Complete context for Implement Agent
|
||||
|
||||
Read order:
|
||||
1. All files in implement.jsonl (dev specs)
|
||||
2. prd.md (requirements)
|
||||
3. info.md (technical design)
|
||||
"""
|
||||
context_parts = []
|
||||
|
||||
# 1. Read implement.jsonl
|
||||
base_context = get_agent_context(repo_root, task_dir, "implement")
|
||||
if base_context:
|
||||
context_parts.append(base_context)
|
||||
|
||||
# 2. Requirements document
|
||||
prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
|
||||
if prd_content:
|
||||
context_parts.append(f"=== {task_dir}/prd.md (Requirements) ===\n{prd_content}")
|
||||
|
||||
# 3. Technical design
|
||||
info_content = read_file_content(repo_root, f"{task_dir}/info.md")
|
||||
if info_content:
|
||||
context_parts.append(
|
||||
f"=== {task_dir}/info.md (Technical Design) ===\n{info_content}"
|
||||
)
|
||||
|
||||
return "\n\n".join(context_parts)
|
||||
|
||||
|
||||
def get_check_context(repo_root: str, task_dir: str) -> str:
|
||||
"""
|
||||
Context for Check Agent: check.jsonl + prd.md
|
||||
"""
|
||||
context_parts = []
|
||||
|
||||
for file_path, content in read_jsonl_entries(repo_root, f"{task_dir}/check.jsonl"):
|
||||
context_parts.append(f"=== {file_path} ===\n{content}")
|
||||
|
||||
prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
|
||||
if prd_content:
|
||||
context_parts.append(f"=== {task_dir}/prd.md (Requirements) ===\n{prd_content}")
|
||||
|
||||
return "\n\n".join(context_parts)
|
||||
|
||||
|
||||
def get_finish_context(repo_root: str, task_dir: str) -> str:
|
||||
"""
|
||||
Context for Finish phase: reuses check.jsonl + prd.md
|
||||
(Finish is a final check, same context source.)
|
||||
"""
|
||||
return get_check_context(repo_root, task_dir)
|
||||
|
||||
|
||||
|
||||
def build_implement_prompt(original_prompt: str, context: str) -> str:
|
||||
"""Build complete prompt for Implement"""
|
||||
return f"""# Implement Agent Task
|
||||
|
||||
You are the Implement Agent in the Multi-Agent Pipeline.
|
||||
|
||||
## Your Context
|
||||
|
||||
All the information you need has been prepared for you:
|
||||
|
||||
{context}
|
||||
|
||||
---
|
||||
|
||||
## Your Task
|
||||
|
||||
{original_prompt}
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
1. **Understand specs** - All dev specs are injected above, understand them
|
||||
2. **Understand requirements** - Read requirements document and technical design
|
||||
3. **Implement feature** - Implement following specs and design
|
||||
4. **Self-check** - Ensure code quality against check specs
|
||||
|
||||
## Important Constraints
|
||||
|
||||
- Do NOT execute git commit, only code modifications
|
||||
- Follow all dev specs injected above
|
||||
- Report list of modified/created files when done"""
|
||||
|
||||
|
||||
def build_check_prompt(original_prompt: str, context: str) -> str:
|
||||
"""Build complete prompt for Check"""
|
||||
return f"""# Check Agent Task
|
||||
|
||||
You are the Check Agent in the Multi-Agent Pipeline (code and cross-layer checker).
|
||||
|
||||
## Your Context
|
||||
|
||||
All check specs and dev specs you need:
|
||||
|
||||
{context}
|
||||
|
||||
---
|
||||
|
||||
## Your Task
|
||||
|
||||
{original_prompt}
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
1. **Get changes** - Run `git diff --name-only` and `git diff` to get code changes
|
||||
2. **Check against specs** - Check item by item against specs above
|
||||
3. **Self-fix** - Fix issues directly, don't just report
|
||||
4. **Run verification** - Run project's lint and typecheck commands
|
||||
|
||||
## Important Constraints
|
||||
|
||||
- Fix issues yourself, don't just report
|
||||
- Must execute complete checklist in check specs
|
||||
- Pay special attention to impact radius analysis (L1-L5)"""
|
||||
|
||||
|
||||
def build_finish_prompt(original_prompt: str, context: str) -> str:
|
||||
"""Build complete prompt for Finish (final check before PR)"""
|
||||
return f"""# Finish Agent Task
|
||||
|
||||
You are performing the final check before creating a PR.
|
||||
|
||||
## Your Context
|
||||
|
||||
Finish checklist and requirements:
|
||||
|
||||
{context}
|
||||
|
||||
---
|
||||
|
||||
## Your Task
|
||||
|
||||
{original_prompt}
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
1. **Review changes** - Run `git diff --name-only` to see all changed files
|
||||
2. **Verify requirements** - Check each requirement in prd.md is implemented
|
||||
3. **Spec sync** - Analyze whether changes introduce new patterns, contracts, or conventions
|
||||
- If new pattern/convention found: read target spec file → update it → update index.md if needed
|
||||
- If infra/cross-layer change: follow the 7-section mandatory template from update-spec.md
|
||||
- If pure code fix with no new patterns: skip this step
|
||||
4. **Run final checks** - Execute lint and typecheck
|
||||
5. **Confirm ready** - Ensure code is ready for PR
|
||||
|
||||
## Important Constraints
|
||||
|
||||
- You MAY update spec files when gaps are detected (use update-spec.md as guide)
|
||||
- MUST read the target spec file BEFORE editing (avoid duplicating existing content)
|
||||
- Do NOT update specs for trivial changes (typos, formatting, obvious fixes)
|
||||
- If critical CODE issues found, report them clearly (fix specs, not code)
|
||||
- Verify all acceptance criteria in prd.md are met"""
|
||||
|
||||
|
||||
|
||||
def get_research_context(repo_root: str, task_dir: str | None) -> str:
|
||||
"""
|
||||
Context for Research Agent — project structure overview for spec directories.
|
||||
|
||||
`task_dir` kept for signature parity with get_implement_context / get_check_context
|
||||
so the dispatcher can call them uniformly.
|
||||
"""
|
||||
_ = task_dir
|
||||
context_parts = []
|
||||
|
||||
# 1. Project structure overview (dynamically discover spec directories)
|
||||
spec_path = f"{DIR_WORKFLOW}/{DIR_SPEC}"
|
||||
spec_root = Path(repo_root) / DIR_WORKFLOW / DIR_SPEC
|
||||
|
||||
# Build spec tree dynamically
|
||||
tree_lines = [f"{spec_path}/"]
|
||||
if spec_root.is_dir():
|
||||
pkg_dirs = sorted(d for d in spec_root.iterdir() if d.is_dir())
|
||||
for i, pkg_dir in enumerate(pkg_dirs):
|
||||
is_last = i == len(pkg_dirs) - 1
|
||||
prefix = "└── " if is_last else "├── "
|
||||
layers = sorted(d.name for d in pkg_dir.iterdir() if d.is_dir())
|
||||
layer_info = f" ({', '.join(layers)})" if layers else ""
|
||||
tree_lines.append(f"{prefix}{pkg_dir.name}/{layer_info}")
|
||||
|
||||
spec_tree = "\n".join(tree_lines)
|
||||
|
||||
project_structure = f"""## Project Spec Directory Structure
|
||||
|
||||
```
|
||||
{spec_tree}
|
||||
```
|
||||
|
||||
To get structured package info, run: `python3 ./{DIR_WORKFLOW}/scripts/get_context.py --mode packages`
|
||||
|
||||
## Search Tips
|
||||
|
||||
- Spec files: `{spec_path}/**/*.md`
|
||||
- Code search: Use Glob and Grep tools
|
||||
- Tech solutions: Use mcp__exa__web_search_exa or mcp__exa__get_code_context_exa"""
|
||||
|
||||
context_parts.append(project_structure)
|
||||
|
||||
return "\n\n".join(context_parts)
|
||||
|
||||
|
||||
def build_research_prompt(original_prompt: str, context: str) -> str:
|
||||
"""Build complete prompt for Research"""
|
||||
return f"""# Research Agent Task
|
||||
|
||||
You are the Research Agent in the Multi-Agent Pipeline (search researcher).
|
||||
|
||||
## Core Principle
|
||||
|
||||
**You do one thing: find and explain information.**
|
||||
|
||||
You are a documenter, not a reviewer.
|
||||
|
||||
## Project Info
|
||||
|
||||
{context}
|
||||
|
||||
---
|
||||
|
||||
## Your Task
|
||||
|
||||
{original_prompt}
|
||||
|
||||
---
|
||||
|
||||
## Workflow
|
||||
|
||||
1. **Understand query** - Determine search type (internal/external) and scope
|
||||
2. **Plan search** - List search steps for complex queries
|
||||
3. **Execute search** - Execute multiple independent searches in parallel
|
||||
4. **Organize results** - Output structured report
|
||||
|
||||
## Search Tools
|
||||
|
||||
| Tool | Purpose |
|
||||
|------|---------|
|
||||
| Glob | Search by filename pattern |
|
||||
| Grep | Search by content |
|
||||
| Read | Read file content |
|
||||
| mcp__exa__web_search_exa | External web search |
|
||||
| mcp__exa__get_code_context_exa | External code/doc search |
|
||||
|
||||
## Strict Boundaries
|
||||
|
||||
**Only allowed**: Describe what exists, where it is, how it works
|
||||
|
||||
**Forbidden** (unless explicitly asked):
|
||||
- Suggest improvements
|
||||
- Criticize implementation
|
||||
- Recommend refactoring
|
||||
- Modify any files
|
||||
|
||||
## Report Format
|
||||
|
||||
Provide structured search results including:
|
||||
- List of files found (with paths)
|
||||
- Code pattern analysis (if applicable)
|
||||
- Related spec documents
|
||||
- External references (if any)"""
|
||||
|
||||
|
||||
def _parse_hook_input(input_data: dict) -> tuple[str, str, dict]:
|
||||
"""Parse hook input across different platform formats.
|
||||
|
||||
Returns (subagent_type, original_prompt, tool_input).
|
||||
Handles:
|
||||
- Claude Code / Qoder / CodeBuddy / Droid: tool_name=Task|Agent, tool_input.subagent_type
|
||||
- Cursor: tool_name=Task, tool_input.subagent_type
|
||||
- Copilot CLI: toolName=task (camelCase key, lowercase value)
|
||||
- Gemini CLI: tool_name IS the agent name (BeforeTool matcher already filtered)
|
||||
- Kiro: agentSpawn hook, agent_name field at top level
|
||||
"""
|
||||
tool_input = input_data.get("tool_input", {})
|
||||
|
||||
# Standard format: Task/Agent tool with subagent_type
|
||||
tool_name = input_data.get("tool_name", "") or input_data.get("toolName", "")
|
||||
if tool_name.lower() in ("task", "agent"):
|
||||
return (
|
||||
tool_input.get("subagent_type", ""),
|
||||
tool_input.get("prompt", ""),
|
||||
tool_input,
|
||||
)
|
||||
|
||||
# Kiro: agentSpawn hook passes agent_name at top level
|
||||
agent_name = input_data.get("agent_name", "")
|
||||
if agent_name:
|
||||
return agent_name, tool_input.get("prompt", input_data.get("prompt", "")), tool_input
|
||||
|
||||
# Gemini CLI: BeforeTool where tool_name IS the agent name
|
||||
# (matcher already ensured it's one of our agents)
|
||||
if tool_name in AGENTS_ALL:
|
||||
return tool_name, tool_input.get("prompt", ""), tool_input
|
||||
|
||||
# Copilot CLI: toolName field (camelCase), value might be the agent name
|
||||
tool_name_camel = input_data.get("toolName", "")
|
||||
if tool_name_camel in AGENTS_ALL:
|
||||
return tool_name_camel, input_data.get("toolArgs", ""), tool_input
|
||||
|
||||
return "", "", tool_input
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
input_data = json.load(sys.stdin)
|
||||
except json.JSONDecodeError:
|
||||
sys.exit(0)
|
||||
|
||||
subagent_type, original_prompt, tool_input = _parse_hook_input(input_data)
|
||||
cwd = input_data.get("cwd", os.getcwd())
|
||||
|
||||
# Only handle subagent types we care about
|
||||
if subagent_type not in AGENTS_ALL:
|
||||
sys.exit(0)
|
||||
|
||||
# Find repo root
|
||||
repo_root = find_repo_root(cwd)
|
||||
if not repo_root:
|
||||
sys.exit(0)
|
||||
|
||||
# Get current task directory (research doesn't require it)
|
||||
task_dir = get_current_task(repo_root)
|
||||
|
||||
# implement/check need task directory
|
||||
if subagent_type in AGENTS_REQUIRE_TASK:
|
||||
if not task_dir:
|
||||
sys.exit(0)
|
||||
# Check if task directory exists
|
||||
task_dir_full = os.path.join(repo_root, task_dir)
|
||||
if not os.path.exists(task_dir_full):
|
||||
sys.exit(0)
|
||||
|
||||
# Check for [finish] marker in prompt (check agent with finish context)
|
||||
is_finish_phase = "[finish]" in original_prompt.lower()
|
||||
|
||||
# Get context and build prompt based on subagent type
|
||||
if subagent_type == AGENT_IMPLEMENT:
|
||||
assert task_dir is not None # validated above
|
||||
context = get_implement_context(repo_root, task_dir)
|
||||
new_prompt = build_implement_prompt(original_prompt, context)
|
||||
elif subagent_type == AGENT_CHECK:
|
||||
assert task_dir is not None # validated above
|
||||
if is_finish_phase:
|
||||
# Finish phase: use finish context (lighter, focused on final verification)
|
||||
context = get_finish_context(repo_root, task_dir)
|
||||
new_prompt = build_finish_prompt(original_prompt, context)
|
||||
else:
|
||||
# Regular check phase: use check context (full specs for self-fix loop)
|
||||
context = get_check_context(repo_root, task_dir)
|
||||
new_prompt = build_check_prompt(original_prompt, context)
|
||||
elif subagent_type == AGENT_RESEARCH:
|
||||
# Research can work without task directory
|
||||
context = get_research_context(repo_root, task_dir)
|
||||
new_prompt = build_research_prompt(original_prompt, context)
|
||||
else:
|
||||
sys.exit(0)
|
||||
|
||||
if not context:
|
||||
sys.exit(0)
|
||||
|
||||
# Return updated input — use a multi-format output that covers all platforms.
|
||||
# Most platforms ignore unrecognized fields, so we include multiple formats.
|
||||
# The platform picks whichever fields it understands.
|
||||
updated = {**tool_input, "prompt": new_prompt}
|
||||
output = {
|
||||
# Claude Code / Qoder / CodeBuddy / Droid format
|
||||
"hookSpecificOutput": {
|
||||
"hookEventName": "PreToolUse",
|
||||
"permissionDecision": "allow",
|
||||
"updatedInput": updated,
|
||||
},
|
||||
# Cursor format
|
||||
"permission": "allow",
|
||||
"updated_input": updated,
|
||||
# Gemini format
|
||||
"updatedInput": updated,
|
||||
}
|
||||
|
||||
print(json.dumps(output, ensure_ascii=False))
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
247
.cursor/hooks/inject-workflow-state.py
Normal file
247
.cursor/hooks/inject-workflow-state.py
Normal file
@@ -0,0 +1,247 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Trellis UserPromptSubmit hook: inject per-turn workflow breadcrumb.
|
||||
|
||||
Runs on every user prompt. Reads the active task (.trellis/.current-task)
|
||||
and emits a short <workflow-state> block reminding the main AI what task
|
||||
is active and its expected flow. Breadcrumb text is pulled from
|
||||
workflow.md [workflow-state:STATUS] tag blocks (single source of truth
|
||||
for users who fork the Trellis workflow), with hardcoded fallbacks so
|
||||
the hook never breaks when workflow.md is missing or malformed.
|
||||
|
||||
Shared across all hook-capable platforms (Claude, Cursor, Codex, Qoder,
|
||||
CodeBuddy, Droid, Gemini, Copilot). Kiro is not wired (no per-turn
|
||||
hook entry point). Written to each platform's hooks directory via
|
||||
writeSharedHooks() at init time.
|
||||
|
||||
Silent exit 0 cases (no output):
|
||||
- No .trellis/ directory found (not a Trellis project)
|
||||
- No .current-task file, or it's empty
|
||||
- task.json malformed or missing status
|
||||
|
||||
Unknown status (no tag + no hardcoded fallback) emits a generic
|
||||
breadcrumb rather than silent-exiting, so custom statuses surface in
|
||||
the UI instead of appearing as "randomly broken".
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import Optional, Tuple
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# CWD-robust Trellis root discovery (fixes hook-path-robustness for this hook)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def find_trellis_root(start: Path) -> Optional[Path]:
|
||||
"""Walk up from start to find directory containing .trellis/.
|
||||
|
||||
Handles CWD drift: subdirectory launches, monorepo packages, etc.
|
||||
Returns None if no .trellis/ found (silent no-op).
|
||||
"""
|
||||
cur = start.resolve()
|
||||
while cur != cur.parent:
|
||||
if (cur / ".trellis").is_dir():
|
||||
return cur
|
||||
cur = cur.parent
|
||||
return None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Active task discovery
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _normalize_task_ref(task_ref: str) -> str:
|
||||
"""Normalize .current-task path ref.
|
||||
|
||||
Accepts:
|
||||
- Absolute paths (left as-is)
|
||||
- Windows-style backslashes (converted to forward slash)
|
||||
- Legacy relative refs like "tasks/foo" (prefixed with .trellis/)
|
||||
"""
|
||||
normalized = task_ref.strip()
|
||||
if not normalized:
|
||||
return ""
|
||||
path_obj = Path(normalized)
|
||||
if path_obj.is_absolute():
|
||||
return str(path_obj)
|
||||
normalized = normalized.replace("\\", "/")
|
||||
while normalized.startswith("./"):
|
||||
normalized = normalized[2:]
|
||||
if normalized.startswith("tasks/"):
|
||||
normalized = f".trellis/{normalized}"
|
||||
return normalized
|
||||
|
||||
|
||||
def get_active_task(root: Path) -> Optional[Tuple[str, str]]:
|
||||
"""Return (task_id, status) from the current active task, else None.
|
||||
|
||||
Reads .trellis/.current-task (a path relative to root, e.g.
|
||||
".trellis/tasks/04-17-foo") then that task's task.json.
|
||||
Normalizes backslashes so Windows paths work on Unix and vice versa.
|
||||
"""
|
||||
ref_file = root / ".trellis" / ".current-task"
|
||||
if not ref_file.is_file():
|
||||
return None
|
||||
try:
|
||||
raw = ref_file.read_text(encoding="utf-8").strip()
|
||||
except OSError:
|
||||
return None
|
||||
task_ref = _normalize_task_ref(raw)
|
||||
if not task_ref:
|
||||
return None
|
||||
|
||||
path_obj = Path(task_ref)
|
||||
task_dir = path_obj if path_obj.is_absolute() else root / path_obj
|
||||
task_json = task_dir / "task.json"
|
||||
if not task_json.is_file():
|
||||
return None
|
||||
try:
|
||||
data = json.loads(task_json.read_text(encoding="utf-8"))
|
||||
except (json.JSONDecodeError, OSError):
|
||||
return None
|
||||
|
||||
task_id = data.get("id") or task_dir.name
|
||||
status = data.get("status", "")
|
||||
if not isinstance(status, str) or not status:
|
||||
return None
|
||||
return task_id, status
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Breadcrumb loading: parse workflow.md, fall back to hardcoded defaults
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
# Supports STATUS values with letters, digits, underscores, hyphens
|
||||
# (so "in-review" / "blocked-by-team" work alongside "in_progress").
|
||||
_TAG_RE = re.compile(
|
||||
r"\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n(.*?)\n\s*\[/workflow-state:\1\]",
|
||||
re.DOTALL,
|
||||
)
|
||||
|
||||
# Hardcoded defaults for built-in Trellis statuses. Used when workflow.md is
|
||||
# missing, malformed, or lacks the tag for this status.
|
||||
#
|
||||
# `no_task` is a pseudo-status emitted when .current-task is missing — it keeps
|
||||
# the Next-Action reminder flowing per-turn even without an active task.
|
||||
_FALLBACK_BREADCRUMBS = {
|
||||
"no_task": (
|
||||
"No active task.\n"
|
||||
"Trigger words in the user message that REQUIRE creating a task "
|
||||
"(non-negotiable, do NOT self-exempt): 重构 / 抽成 / 独立 / 分发 / "
|
||||
"拆出来 / 搞一个 / 做成 / 接入 / 集成 / refactor / rewrite / extract / "
|
||||
"productize / publish / build X / design Y.\n"
|
||||
"Task is NOT required ONLY if ALL three hold: (a) zero file writes "
|
||||
"this turn, (b) answer fits in one reply with no multi-round plan, "
|
||||
"(c) no research beyond reading 1-2 repo files.\n"
|
||||
"When in doubt: create task. Over-tasking is cheap; under-tasking "
|
||||
"leaks plans and research into main context.\n"
|
||||
"Flow: load `trellis-brainstorm` skill → it creates the task via "
|
||||
"`python3 ./.trellis/scripts/task.py create` and drives requirements Q&A. "
|
||||
"For research-heavy work (tool comparison, docs, cross-platform survey), "
|
||||
"spawn `trellis-research` sub-agents via Task tool — NEVER do 3+ inline "
|
||||
"WebFetch/WebSearch/`gh api` calls in the main conversation."
|
||||
),
|
||||
"planning": (
|
||||
"Complete prd.md via trellis-brainstorm skill; then run task.py start.\n"
|
||||
"Research belongs in `{task_dir}/research/*.md`, written by "
|
||||
"`trellis-research` sub-agents. Do NOT inline WebFetch/WebSearch in "
|
||||
"main session — PRD only links to research files."
|
||||
),
|
||||
"in_progress": (
|
||||
"Flow: trellis-implement → trellis-check → trellis-update-spec → finish\n"
|
||||
"Next required action: inspect conversation history + git status, then "
|
||||
"execute the next uncompleted step in that sequence.\n"
|
||||
"For agent-capable platforms, do NOT edit code in the main session; "
|
||||
"dispatch `trellis-implement` for implementation and dispatch "
|
||||
"`trellis-check` before reporting completion."
|
||||
),
|
||||
"completed": (
|
||||
"User commits changes; then run task.py archive."
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def load_breadcrumbs(root: Path) -> dict[str, str]:
|
||||
"""Parse workflow.md for [workflow-state:STATUS] blocks.
|
||||
|
||||
Returns {status: body_text}. Missing tags fall back to hardcoded
|
||||
defaults so the hook always has something to say for built-in
|
||||
statuses. Custom statuses without tags fall to generic breadcrumb
|
||||
downstream (see build_breadcrumb).
|
||||
"""
|
||||
result = dict(_FALLBACK_BREADCRUMBS)
|
||||
|
||||
workflow = root / ".trellis" / "workflow.md"
|
||||
if not workflow.is_file():
|
||||
return result
|
||||
try:
|
||||
content = workflow.read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
return result
|
||||
|
||||
for match in _TAG_RE.finditer(content):
|
||||
status = match.group(1)
|
||||
body = match.group(2).strip()
|
||||
if body:
|
||||
result[status] = body
|
||||
return result
|
||||
|
||||
|
||||
def build_breadcrumb(
|
||||
task_id: Optional[str], status: str, templates: dict[str, str]
|
||||
) -> str:
|
||||
"""Build the <workflow-state>...</workflow-state> block.
|
||||
|
||||
- Known status (in templates or fallback) → detailed template body
|
||||
- Unknown status (no tag + no fallback) → generic "refer to workflow.md"
|
||||
- `no_task` pseudo-status (task_id is None) → header omits task info
|
||||
"""
|
||||
body = templates.get(status)
|
||||
if body is None:
|
||||
body = "Refer to workflow.md for current step."
|
||||
header = f"Status: {status}" if task_id is None else f"Task: {task_id} ({status})"
|
||||
return f"<workflow-state>\n{header}\n{body}\n</workflow-state>"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Entry
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
data = json.load(sys.stdin)
|
||||
except (json.JSONDecodeError, ValueError):
|
||||
data = {}
|
||||
|
||||
cwd_str = data.get("cwd") or os.getcwd()
|
||||
cwd = Path(cwd_str)
|
||||
|
||||
root = find_trellis_root(cwd)
|
||||
if root is None:
|
||||
return 0 # not a Trellis project
|
||||
|
||||
templates = load_breadcrumbs(root)
|
||||
task = get_active_task(root)
|
||||
if task is None:
|
||||
# No active task — still emit a breadcrumb nudging AI toward
|
||||
# trellis-brainstorm + task.py create when user describes real work.
|
||||
breadcrumb = build_breadcrumb(None, "no_task", templates)
|
||||
else:
|
||||
breadcrumb = build_breadcrumb(*task, templates=templates)
|
||||
|
||||
output = {
|
||||
"hookSpecificOutput": {
|
||||
"hookEventName": "UserPromptSubmit",
|
||||
"additionalContext": breadcrumb,
|
||||
}
|
||||
}
|
||||
print(json.dumps(output))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
577
.cursor/hooks/session-start.py
Normal file
577
.cursor/hooks/session-start.py
Normal file
@@ -0,0 +1,577 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Session Start Hook - Inject structured context
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
# IMPORTANT: Suppress all warnings FIRST
|
||||
import warnings
|
||||
warnings.filterwarnings("ignore")
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from io import StringIO
|
||||
from pathlib import Path
|
||||
|
||||
FIRST_REPLY_NOTICE = """<first-reply-notice>
|
||||
On the first visible assistant reply in this session, begin with exactly one short Chinese sentence:
|
||||
Trellis SessionStart 已注入：workflow、当前任务状态、开发者身份、git 状态、active tasks、spec 索引已加载。
|
||||
Then continue directly with the user's request. This notice is one-shot: do not repeat it after the first assistant reply in the same session.
|
||||
</first-reply-notice>"""
|
||||
|
||||
# IMPORTANT: Force stdout to use UTF-8 on Windows
|
||||
# This fixes UnicodeEncodeError when outputting non-ASCII characters
|
||||
if sys.platform.startswith("win"):
|
||||
import io as _io
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8", errors="replace") # type: ignore[union-attr]
|
||||
elif hasattr(sys.stdout, "detach"):
|
||||
sys.stdout = _io.TextIOWrapper(sys.stdout.detach(), encoding="utf-8", errors="replace") # type: ignore[union-attr]
|
||||
|
||||
|
||||
|
||||
def _has_curated_jsonl_entry(jsonl_path: Path) -> bool:
|
||||
"""Return True iff jsonl has at least one row with a ``file`` field.
|
||||
|
||||
A freshly seeded jsonl only contains a ``{"_example": ...}`` row (no
|
||||
``file`` key) — that is NOT "ready". Readiness requires at least one
|
||||
curated entry. Matches the contract used by ``inject-subagent-context.py``.
|
||||
"""
|
||||
try:
|
||||
for line in jsonl_path.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
try:
|
||||
row = json.loads(line)
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
if isinstance(row, dict) and row.get("file"):
|
||||
return True
|
||||
except (OSError, UnicodeDecodeError):
|
||||
return False
|
||||
return False
|
||||
|
||||
|
||||
def should_skip_injection() -> bool:
|
||||
"""Check if any platform's non-interactive flag is set."""
|
||||
non_interactive_vars = [
|
||||
"CLAUDE_NON_INTERACTIVE",
|
||||
"QODER_NON_INTERACTIVE",
|
||||
"CODEBUDDY_NON_INTERACTIVE",
|
||||
"FACTORY_NON_INTERACTIVE",
|
||||
"CURSOR_NON_INTERACTIVE",
|
||||
"GEMINI_NON_INTERACTIVE",
|
||||
"KIRO_NON_INTERACTIVE",
|
||||
"COPILOT_NON_INTERACTIVE",
|
||||
]
|
||||
return any(os.environ.get(var) == "1" for var in non_interactive_vars)
|
||||
|
||||
|
||||
def read_file(path: Path, fallback: str = "") -> str:
|
||||
try:
|
||||
return path.read_text(encoding="utf-8")
|
||||
except (FileNotFoundError, PermissionError):
|
||||
return fallback
|
||||
|
||||
|
||||
def run_script(script_path: Path) -> str:
|
||||
try:
|
||||
if script_path.suffix == ".py":
|
||||
# Add PYTHONIOENCODING to force UTF-8 in subprocess
|
||||
env = os.environ.copy()
|
||||
env["PYTHONIOENCODING"] = "utf-8"
|
||||
cmd = [sys.executable, "-W", "ignore", str(script_path)]
|
||||
else:
|
||||
env = os.environ
|
||||
cmd = [str(script_path)]
|
||||
|
||||
result = subprocess.run(
|
||||
cmd,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
errors="replace",
|
||||
timeout=5,
|
||||
cwd=script_path.parent.parent.parent,
|
||||
env=env,
|
||||
)
|
||||
return result.stdout if result.returncode == 0 else "No context available"
|
||||
except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError):
|
||||
return "No context available"
|
||||
|
||||
|
||||
def _normalize_task_ref(task_ref: str) -> str:
|
||||
normalized = task_ref.strip()
|
||||
if not normalized:
|
||||
return ""
|
||||
|
||||
path_obj = Path(normalized)
|
||||
if path_obj.is_absolute():
|
||||
return str(path_obj)
|
||||
|
||||
normalized = normalized.replace("\\", "/")
|
||||
while normalized.startswith("./"):
|
||||
normalized = normalized[2:]
|
||||
|
||||
if normalized.startswith("tasks/"):
|
||||
return f".trellis/{normalized}"
|
||||
|
||||
return normalized
|
||||
|
||||
|
||||
def _resolve_task_dir(trellis_dir: Path, task_ref: str) -> Path:
|
||||
normalized = _normalize_task_ref(task_ref)
|
||||
path_obj = Path(normalized)
|
||||
if path_obj.is_absolute():
|
||||
return path_obj
|
||||
if normalized.startswith(".trellis/"):
|
||||
return trellis_dir.parent / path_obj
|
||||
return trellis_dir / "tasks" / path_obj
|
||||
|
||||
|
||||
def _get_task_status(trellis_dir: Path) -> str:
|
||||
"""Check current task status and return structured status string with explicit next action.
|
||||
|
||||
Returns a block with three fields:
|
||||
- Status: current state
|
||||
- Task: task identifier (when applicable)
|
||||
- Next-Action: explicit skill/command/tool call the AI should invoke
|
||||
"""
|
||||
current_task_file = trellis_dir / ".current-task"
|
||||
|
||||
# Case 1: No active task — waiting for user to describe intent
|
||||
if not current_task_file.is_file() or not current_task_file.read_text(encoding="utf-8").strip():
|
||||
return (
|
||||
"Status: NO ACTIVE TASK\n"
|
||||
"Next-Action: After the user describes their intent, load skill `trellis-brainstorm` "
|
||||
"to clarify requirements and create a task via `python3 ./.trellis/scripts/task.py create`.\n"
|
||||
"Research reminder: for research-heavy tasks (comparing tools, reading external docs, "
|
||||
"cross-platform surveys), spawn `trellis-research` sub-agents via the Task tool — "
|
||||
"they persist findings to `{TASK_DIR}/research/*.md` and keep main context clean. "
|
||||
"Do NOT do 10+ inline WebFetch/WebSearch in the main conversation."
|
||||
)
|
||||
|
||||
task_ref = _normalize_task_ref(current_task_file.read_text(encoding="utf-8").strip())
|
||||
|
||||
# Case 2: Stale pointer — task dir was deleted
|
||||
task_dir = _resolve_task_dir(trellis_dir, task_ref)
|
||||
if not task_dir.is_dir():
|
||||
return (
|
||||
f"Status: STALE POINTER\nTask: {task_ref}\n"
|
||||
f"Next-Action: Run `python3 ./.trellis/scripts/task.py finish` to clear the stale pointer, "
|
||||
"then ask the user what to work on next."
|
||||
)
|
||||
|
||||
# Read task.json
|
||||
task_json_path = task_dir / "task.json"
|
||||
task_data = {}
|
||||
if task_json_path.is_file():
|
||||
try:
|
||||
task_data = json.loads(task_json_path.read_text(encoding="utf-8"))
|
||||
except (json.JSONDecodeError, PermissionError):
|
||||
pass
|
||||
|
||||
task_title = task_data.get("title", task_ref)
|
||||
task_status = task_data.get("status", "unknown")
|
||||
|
||||
# Case 3: Task completed — time to archive
|
||||
if task_status == "completed":
|
||||
return (
|
||||
f"Status: COMPLETED\nTask: {task_title}\n"
|
||||
f"Next-Action: Load skill `trellis-update-spec` to capture learnings, "
|
||||
f"then archive with `python3 ./.trellis/scripts/task.py archive {task_dir.name}`."
|
||||
)
|
||||
|
||||
has_prd = (task_dir / "prd.md").is_file()
|
||||
|
||||
# Case 4: No PRD — still in Plan phase
|
||||
if not has_prd:
|
||||
return (
|
||||
f"Status: PLANNING\nTask: {task_title}\n"
|
||||
"Next-Action: Load skill `trellis-brainstorm` to clarify requirements with the user "
|
||||
"and produce prd.md in the task directory.\n"
|
||||
"Research reminder: when the task needs external research (tool comparison, docs, "
|
||||
"conventions survey), spawn `trellis-research` sub-agents — don't WebFetch/WebSearch "
|
||||
"inline in the main session. Findings go to `{task_dir}/research/*.md`; PRD only links to them."
|
||||
)
|
||||
|
||||
# Case 4b: PRD exists but implement.jsonl has only seed (no curated entries) — Phase 1.3 gate
|
||||
implement_jsonl = task_dir / "implement.jsonl"
|
||||
if implement_jsonl.is_file() and not _has_curated_jsonl_entry(implement_jsonl):
|
||||
return (
|
||||
f"Status: PLANNING (Phase 1.3)\nTask: {task_title}\n"
|
||||
"Next-Action: Curate `implement.jsonl` and `check.jsonl` with the spec + research files "
|
||||
"the Phase 2 sub-agents will need. Only spec paths (`.trellis/spec/**/*.md`) and research "
|
||||
"files (`{TASK_DIR}/research/*.md`) — no code paths. Run "
|
||||
"`python3 ./.trellis/scripts/get_context.py --mode packages` to list available specs, "
|
||||
"then edit the jsonl files or use `python3 ./.trellis/scripts/task.py add-context`. "
|
||||
"See `.trellis/workflow.md` Phase 1.3 for details."
|
||||
)
|
||||
|
||||
# Case 5: PRD + curated jsonl (or agent-less platform with no jsonl) — enter Execute phase
|
||||
return (
|
||||
f"Status: READY\nTask: {task_title}\n"
|
||||
"Next required action: dispatch `trellis-implement` per Phase 2.1. "
|
||||
"For agent-capable platforms, do NOT edit code in the main session. "
|
||||
"After implementation, dispatch `trellis-check` per Phase 2.2 before reporting completion.\n"
|
||||
"Sub-agent roster: `trellis-implement` (writes code), `trellis-check` (verifies + self-fixes), "
|
||||
"`trellis-research` (persists findings to `research/*.md` — use when you'd otherwise do "
|
||||
"multiple WebFetch/WebSearch inline)."
|
||||
)
|
||||
|
||||
|
||||
def _load_trellis_config(trellis_dir: Path) -> tuple:
|
||||
"""Load Trellis config for session-start decisions.
|
||||
|
||||
Returns:
|
||||
(is_mono, packages_dict, spec_scope, task_pkg, default_pkg)
|
||||
"""
|
||||
scripts_dir = trellis_dir / "scripts"
|
||||
if str(scripts_dir) not in sys.path:
|
||||
sys.path.insert(0, str(scripts_dir))
|
||||
|
||||
try:
|
||||
from common.config import get_default_package, get_packages, get_spec_scope, is_monorepo # type: ignore[import-not-found]
|
||||
from common.paths import get_current_task # type: ignore[import-not-found]
|
||||
|
||||
repo_root = trellis_dir.parent
|
||||
is_mono = is_monorepo(repo_root)
|
||||
packages = get_packages(repo_root) or {}
|
||||
scope = get_spec_scope(repo_root)
|
||||
|
||||
# Get active task's package
|
||||
task_pkg = None
|
||||
current = get_current_task(repo_root)
|
||||
if current:
|
||||
task_json = repo_root / current / "task.json"
|
||||
if task_json.is_file():
|
||||
try:
|
||||
data = json.loads(task_json.read_text(encoding="utf-8"))
|
||||
if isinstance(data, dict):
|
||||
tp = data.get("package")
|
||||
if isinstance(tp, str) and tp:
|
||||
task_pkg = tp
|
||||
except (json.JSONDecodeError, OSError):
|
||||
pass
|
||||
|
||||
default_pkg = get_default_package(repo_root)
|
||||
return is_mono, packages, scope, task_pkg, default_pkg
|
||||
except Exception:
|
||||
return False, {}, None, None, None
|
||||
|
||||
|
||||
def _check_legacy_spec(trellis_dir: Path, is_mono: bool, packages: dict) -> str | None:
|
||||
"""Check for legacy spec directory structure in monorepo.
|
||||
|
||||
Returns warning message if legacy structure detected, None otherwise.
|
||||
"""
|
||||
if not is_mono or not packages:
|
||||
return None
|
||||
|
||||
spec_dir = trellis_dir / "spec"
|
||||
if not spec_dir.is_dir():
|
||||
return None
|
||||
|
||||
# Check for legacy flat spec dirs (spec/backend/, spec/frontend/ with index.md)
|
||||
has_legacy = False
|
||||
for legacy_name in ("backend", "frontend"):
|
||||
legacy_dir = spec_dir / legacy_name
|
||||
if legacy_dir.is_dir() and (legacy_dir / "index.md").is_file():
|
||||
has_legacy = True
|
||||
break
|
||||
|
||||
if not has_legacy:
|
||||
return None
|
||||
|
||||
# Check which packages are missing spec/<pkg>/ directory
|
||||
missing = [
|
||||
name for name in sorted(packages.keys())
|
||||
if not (spec_dir / name).is_dir()
|
||||
]
|
||||
|
||||
if not missing:
|
||||
return None # All packages have spec dirs
|
||||
|
||||
if len(missing) == len(packages):
|
||||
return (
|
||||
f"[!] Legacy spec structure detected: found `spec/backend/` or `spec/frontend/` "
|
||||
f"but no package-scoped `spec/<package>/` directories.\n"
|
||||
f"Monorepo packages: {', '.join(sorted(packages.keys()))}\n"
|
||||
f"Please reorganize: `spec/backend/` -> `spec/<package>/backend/`"
|
||||
)
|
||||
return (
|
||||
f"[!] Partial spec migration detected: packages {', '.join(missing)} "
|
||||
f"still missing `spec/<pkg>/` directory.\n"
|
||||
f"Please complete migration for all packages."
|
||||
)
|
||||
|
||||
|
||||
def _resolve_spec_scope(
|
||||
is_mono: bool,
|
||||
packages: dict,
|
||||
scope,
|
||||
task_pkg: str | None,
|
||||
default_pkg: str | None,
|
||||
) -> set | None:
|
||||
"""Resolve which packages should have their specs injected.
|
||||
|
||||
Returns:
|
||||
Set of package names to include, or None for full scan.
|
||||
"""
|
||||
if not is_mono or not packages:
|
||||
return None # Single-repo: full scan
|
||||
|
||||
if scope is None:
|
||||
return None # No scope configured: full scan
|
||||
|
||||
if isinstance(scope, str) and scope == "active_task":
|
||||
if task_pkg and task_pkg in packages:
|
||||
return {task_pkg}
|
||||
if default_pkg and default_pkg in packages:
|
||||
return {default_pkg}
|
||||
return None # Fallback to full scan
|
||||
|
||||
if isinstance(scope, list):
|
||||
valid = set()
|
||||
for entry in scope:
|
||||
if entry in packages:
|
||||
valid.add(entry)
|
||||
else:
|
||||
print(
|
||||
f"Warning: spec_scope contains unknown package: {entry}, ignoring",
|
||||
file=sys.stderr,
|
||||
)
|
||||
|
||||
if valid:
|
||||
# Warn if active task is out of scope
|
||||
if task_pkg and task_pkg not in valid:
|
||||
print(
|
||||
f"Warning: active task package '{task_pkg}' is out of configured spec_scope",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return valid
|
||||
|
||||
# All entries invalid: fallback chain
|
||||
print(
|
||||
"Warning: all spec_scope entries invalid, falling back to task/default/full",
|
||||
file=sys.stderr,
|
||||
)
|
||||
if task_pkg and task_pkg in packages:
|
||||
return {task_pkg}
|
||||
if default_pkg and default_pkg in packages:
|
||||
return {default_pkg}
|
||||
return None # Full scan
|
||||
|
||||
return None # Unknown scope type: full scan
|
||||
|
||||
|
||||
def _extract_range(content: str, start_header: str, end_header: str) -> str:
|
||||
"""Extract lines starting at `## start_header` up to (but excluding) `## end_header`.
|
||||
|
||||
Both parameters are full header lines WITHOUT the `## ` prefix (e.g. "Phase Index").
|
||||
Returns empty string if start header is not found.
|
||||
End header missing → extracts to end of file.
|
||||
"""
|
||||
lines = content.splitlines()
|
||||
start: int | None = None
|
||||
end: int = len(lines)
|
||||
start_match = f"## {start_header}"
|
||||
end_match = f"## {end_header}"
|
||||
for i, line in enumerate(lines):
|
||||
stripped = line.strip()
|
||||
if start is None and stripped == start_match:
|
||||
start = i
|
||||
continue
|
||||
if start is not None and stripped == end_match:
|
||||
end = i
|
||||
break
|
||||
if start is None:
|
||||
return ""
|
||||
return "\n".join(lines[start:end]).rstrip()
|
||||
|
||||
|
||||
def _build_workflow_overview(workflow_path: Path) -> str:
|
||||
"""Inject the workflow guide for the session.
|
||||
|
||||
Contents:
|
||||
1. Section index (all `## ` headings — navigation)
|
||||
2. Phase Index section (rules, skill routing table, anti-rationalization table)
|
||||
3. Phase 1/2/3 step-level details (the actual how-to for each step)
|
||||
|
||||
The meta sections (Core Principles / Trellis System / Workflow State
|
||||
Breadcrumbs) are NOT injected — Core Principles is short prose the AI can
|
||||
Read on demand; Trellis System lists reference commands duplicated in
|
||||
step bodies; Breadcrumbs are consumed by the UserPromptSubmit hook.
|
||||
|
||||
Total budget: Phase Index ~2 KB + Phase 1/2/3 ~7 KB = ~9 KB.
|
||||
"""
|
||||
content = read_file(workflow_path)
|
||||
if not content:
|
||||
return "No workflow.md found"
|
||||
|
||||
out_lines = [
|
||||
"# Development Workflow — Section Index",
|
||||
"Full guide: .trellis/workflow.md (read on demand)",
|
||||
"",
|
||||
"## Table of Contents",
|
||||
]
|
||||
for line in content.splitlines():
|
||||
if line.startswith("## "):
|
||||
out_lines.append(line)
|
||||
out_lines += ["", "---", ""]
|
||||
|
||||
# Extract Phase Index through the end of Phase 3 (before Breadcrumbs).
|
||||
# Since sections appear in order Phase Index → Phase 1 → Phase 2 → Phase 3
|
||||
# → Workflow State Breadcrumbs, a single range grab captures all four.
|
||||
phases = _extract_range(
|
||||
content, "Phase Index", "Workflow State Breadcrumbs"
|
||||
)
|
||||
if phases:
|
||||
out_lines.append(phases)
|
||||
|
||||
return "\n".join(out_lines).rstrip()
|
||||
|
||||
|
||||
def main():
|
||||
if should_skip_injection():
|
||||
sys.exit(0)
|
||||
|
||||
# Try platform-specific env vars, fallback to cwd
|
||||
project_dir_env_vars = [
|
||||
"CLAUDE_PROJECT_DIR",
|
||||
"QODER_PROJECT_DIR",
|
||||
"CODEBUDDY_PROJECT_DIR",
|
||||
"FACTORY_PROJECT_DIR",
|
||||
"CURSOR_PROJECT_DIR",
|
||||
"GEMINI_PROJECT_DIR",
|
||||
"KIRO_PROJECT_DIR",
|
||||
"COPILOT_PROJECT_DIR",
|
||||
]
|
||||
project_dir = None
|
||||
for var in project_dir_env_vars:
|
||||
val = os.environ.get(var)
|
||||
if val:
|
||||
project_dir = Path(val).resolve()
|
||||
break
|
||||
if project_dir is None:
|
||||
project_dir = Path(".").resolve()
|
||||
|
||||
trellis_dir = project_dir / ".trellis"
|
||||
|
||||
# Load config for scope filtering and legacy detection
|
||||
is_mono, packages, scope_config, task_pkg, default_pkg = _load_trellis_config(trellis_dir)
|
||||
allowed_pkgs = _resolve_spec_scope(is_mono, packages, scope_config, task_pkg, default_pkg)
|
||||
|
||||
output = StringIO()
|
||||
|
||||
output.write("""<session-context>
|
||||
You are starting a new session in a Trellis-managed project.
|
||||
Read and follow all instructions below carefully.
|
||||
</session-context>
|
||||
|
||||
""")
|
||||
output.write(FIRST_REPLY_NOTICE)
|
||||
output.write("\n\n")
|
||||
|
||||
# Legacy migration warning
|
||||
legacy_warning = _check_legacy_spec(trellis_dir, is_mono, packages)
|
||||
if legacy_warning:
|
||||
output.write(f"<migration-warning>\n{legacy_warning}\n</migration-warning>\n\n")
|
||||
|
||||
output.write("<current-state>\n")
|
||||
context_script = trellis_dir / "scripts" / "get_context.py"
|
||||
output.write(run_script(context_script))
|
||||
output.write("\n</current-state>\n\n")
|
||||
|
||||
output.write("<workflow>\n")
|
||||
output.write(_build_workflow_overview(trellis_dir / "workflow.md"))
|
||||
output.write("\n</workflow>\n\n")
|
||||
|
||||
output.write("<guidelines>\n")
|
||||
output.write(
|
||||
"Project spec indexes are listed by path below. Each index contains a "
|
||||
"**Pre-Development Checklist** listing the specific guideline files to "
|
||||
"read before coding.\n\n"
|
||||
"- If you're spawning an implement/check sub-agent, context is injected "
|
||||
"automatically via `{task}/implement.jsonl` / `check.jsonl`. You do NOT "
|
||||
"need to read these indexes yourself.\n"
|
||||
"- For agent-capable platforms, do NOT edit code directly in the main "
|
||||
"session; dispatch `trellis-implement` and `trellis-check` so JSONL "
|
||||
"context is loaded by the sub-agents.\n\n"
|
||||
)
|
||||
|
||||
# guides/ is cross-package thinking — always include inline (small, broadly useful)
|
||||
guides_index = trellis_dir / "spec" / "guides" / "index.md"
|
||||
if guides_index.is_file():
|
||||
output.write("## guides (inlined — cross-package thinking guides)\n")
|
||||
output.write(read_file(guides_index))
|
||||
output.write("\n\n")
|
||||
|
||||
# Other spec indexes — paths only (main agent reads on demand;
|
||||
# sub-agents get their specific specs via jsonl injection)
|
||||
paths: list[str] = []
|
||||
spec_dir = trellis_dir / "spec"
|
||||
if spec_dir.is_dir():
|
||||
for sub in sorted(spec_dir.iterdir()):
|
||||
if not sub.is_dir() or sub.name.startswith("."):
|
||||
continue
|
||||
if sub.name == "guides":
|
||||
continue # already inlined above
|
||||
|
||||
index_file = sub / "index.md"
|
||||
if index_file.is_file():
|
||||
# Flat spec dir (single-repo layer like spec/backend/)
|
||||
paths.append(f".trellis/spec/{sub.name}/index.md")
|
||||
else:
|
||||
# Nested package dirs (monorepo: spec/<pkg>/<layer>/index.md)
|
||||
# Apply scope filter
|
||||
if allowed_pkgs is not None and sub.name not in allowed_pkgs:
|
||||
continue
|
||||
for nested in sorted(sub.iterdir()):
|
||||
if not nested.is_dir():
|
||||
continue
|
||||
nested_index = nested / "index.md"
|
||||
if nested_index.is_file():
|
||||
paths.append(
|
||||
f".trellis/spec/{sub.name}/{nested.name}/index.md"
|
||||
)
|
||||
|
||||
if paths:
|
||||
output.write("## Available spec indexes (read on demand)\n")
|
||||
for p in paths:
|
||||
output.write(f"- {p}\n")
|
||||
output.write("\n")
|
||||
|
||||
output.write(
|
||||
"Discover more via: "
|
||||
"`python3 ./.trellis/scripts/get_context.py --mode packages`\n"
|
||||
)
|
||||
output.write("</guidelines>\n\n")
|
||||
|
||||
# Check task status and inject structured tag
|
||||
task_status = _get_task_status(trellis_dir)
|
||||
output.write(f"<task-status>\n{task_status}\n</task-status>\n\n")
|
||||
|
||||
output.write("""<ready>
|
||||
Context loaded. Workflow index, project state, and guidelines are already injected above — do NOT re-read them.
|
||||
When the user sends the first message, follow <task-status> and the workflow guide.
|
||||
If a task is READY, execute its Next required action without asking whether to continue.
|
||||
</ready>""")
|
||||
|
||||
result = {
|
||||
"hookSpecificOutput": {
|
||||
"hookEventName": "SessionStart",
|
||||
"additionalContext": output.getvalue(),
|
||||
}
|
||||
}
|
||||
|
||||
# Output JSON - stdout is already configured for UTF-8
|
||||
print(json.dumps(result, ensure_ascii=False), flush=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
219
.cursor/hooks/statusline.py
Normal file
219
.cursor/hooks/statusline.py
Normal file
@@ -0,0 +1,219 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Trellis StatusLine — project-level status display for Claude Code.
|
||||
|
||||
Reads Claude Code session JSON from stdin + Trellis task data from filesystem.
|
||||
Outputs 1-2 lines:
|
||||
With active task: [P1] Task title (status) + info line
|
||||
Without task: info line only
|
||||
Info line: model · ctx% · branch · duration · developer · tasks · rate limits
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
# Fix: Windows Python defaults to GBK encoding, which corrupts UTF-8
|
||||
# characters like the middle dot (·). Wrap stdout/stderr with UTF-8.
|
||||
if sys.platform == "win32":
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, "reconfigure", None)
|
||||
if callable(reconfigure):
|
||||
reconfigure(encoding="utf-8", errors="replace")
|
||||
|
||||
|
||||
def _read_text(path: Path) -> str:
|
||||
try:
|
||||
return path.read_text(encoding="utf-8").strip()
|
||||
except (FileNotFoundError, PermissionError, OSError):
|
||||
return ""
|
||||
|
||||
|
||||
def _read_json(path: Path) -> dict:
|
||||
text = _read_text(path)
|
||||
if not text:
|
||||
return {}
|
||||
try:
|
||||
return json.loads(text)
|
||||
except (json.JSONDecodeError, ValueError):
|
||||
return {}
|
||||
|
||||
|
||||
def _normalize_task_ref(task_ref: str) -> str:
|
||||
normalized = task_ref.strip()
|
||||
if not normalized:
|
||||
return ""
|
||||
|
||||
path_obj = Path(normalized)
|
||||
if path_obj.is_absolute():
|
||||
return str(path_obj)
|
||||
|
||||
normalized = normalized.replace("\\", "/")
|
||||
while normalized.startswith("./"):
|
||||
normalized = normalized[2:]
|
||||
|
||||
if normalized.startswith("tasks/"):
|
||||
return f".trellis/{normalized}"
|
||||
|
||||
return normalized
|
||||
|
||||
|
||||
def _resolve_task_dir(trellis_dir: Path, task_ref: str) -> Path:
|
||||
normalized = _normalize_task_ref(task_ref)
|
||||
path_obj = Path(normalized)
|
||||
if path_obj.is_absolute():
|
||||
return path_obj
|
||||
if normalized.startswith(".trellis/"):
|
||||
return trellis_dir.parent / path_obj
|
||||
return trellis_dir / "tasks" / path_obj
|
||||
|
||||
|
||||
def _find_trellis_dir() -> Path | None:
|
||||
"""Walk up from cwd to find .trellis/ directory."""
|
||||
current = Path.cwd()
|
||||
for parent in [current, *current.parents]:
|
||||
candidate = parent / ".trellis"
|
||||
if candidate.is_dir():
|
||||
return candidate
|
||||
return None
|
||||
|
||||
|
||||
def _get_current_task(trellis_dir: Path) -> dict | None:
|
||||
"""Load current task info. Returns dict with title/status/priority or None."""
|
||||
task_ref = _normalize_task_ref(_read_text(trellis_dir / ".current-task"))
|
||||
if not task_ref:
|
||||
return None
|
||||
|
||||
# Resolve task directory
|
||||
task_path = _resolve_task_dir(trellis_dir, task_ref)
|
||||
task_data = _read_json(task_path / "task.json")
|
||||
if not task_data:
|
||||
return None
|
||||
|
||||
return {
|
||||
"title": task_data.get("title") or task_data.get("name") or "unknown",
|
||||
"status": task_data.get("status", "unknown"),
|
||||
"priority": task_data.get("priority", "P2"),
|
||||
}
|
||||
|
||||
|
||||
def _count_active_tasks(trellis_dir: Path) -> int:
|
||||
"""Count non-archived task directories with valid task.json."""
|
||||
tasks_dir = trellis_dir / "tasks"
|
||||
if not tasks_dir.is_dir():
|
||||
return 0
|
||||
count = 0
|
||||
for d in tasks_dir.iterdir():
|
||||
if d.is_dir() and d.name != "archive" and (d / "task.json").is_file():
|
||||
count += 1
|
||||
return count
|
||||
|
||||
|
||||
def _get_developer(trellis_dir: Path) -> str:
|
||||
content = _read_text(trellis_dir / ".developer")
|
||||
if not content:
|
||||
return "unknown"
|
||||
for line in content.splitlines():
|
||||
if line.startswith("name="):
|
||||
return line[5:].strip()
|
||||
return content.splitlines()[0].strip() or "unknown"
|
||||
|
||||
|
||||
def _get_git_branch() -> str:
|
||||
try:
|
||||
result = subprocess.run(
|
||||
["git", "branch", "--show-current"],
|
||||
capture_output=True, text=True, timeout=3,
|
||||
)
|
||||
return result.stdout.strip() if result.returncode == 0 else ""
|
||||
except (FileNotFoundError, subprocess.TimeoutExpired):
|
||||
return ""
|
||||
|
||||
|
||||
def _format_ctx_size(size: int) -> str:
|
||||
if size >= 1_000_000:
|
||||
return f"{size // 1_000_000}M"
|
||||
if size >= 1_000:
|
||||
return f"{size // 1_000}K"
|
||||
return str(size)
|
||||
|
||||
|
||||
def _format_duration(ms: int) -> str:
|
||||
secs = ms // 1000
|
||||
hours, remainder = divmod(secs, 3600)
|
||||
mins = remainder // 60
|
||||
if hours > 0:
|
||||
return f"{hours}h{mins}m"
|
||||
return f"{mins}m"
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Read Claude Code session JSON from stdin
|
||||
try:
|
||||
cc_data = json.loads(sys.stdin.read())
|
||||
except (json.JSONDecodeError, ValueError):
|
||||
cc_data = {}
|
||||
|
||||
trellis_dir = _find_trellis_dir()
|
||||
SEP = " \033[90m·\033[0m "
|
||||
|
||||
# --- Trellis data ---
|
||||
task = _get_current_task(trellis_dir) if trellis_dir else None
|
||||
dev = _get_developer(trellis_dir) if trellis_dir else ""
|
||||
task_count = _count_active_tasks(trellis_dir) if trellis_dir else 0
|
||||
|
||||
# --- CC session data ---
|
||||
model = cc_data.get("model", {}).get("display_name", "?")
|
||||
ctx_pct = int(cc_data.get("context_window", {}).get("used_percentage") or 0)
|
||||
ctx_size = _format_ctx_size(cc_data.get("context_window", {}).get("context_window_size") or 0)
|
||||
duration = _format_duration(cc_data.get("cost", {}).get("total_duration_ms") or 0)
|
||||
branch = _get_git_branch()
|
||||
|
||||
# Avoid "Opus 4.6 (1M context) (1M)"
|
||||
if re.search(r"\d+[KMG]\b", model, re.IGNORECASE):
|
||||
model_label = model
|
||||
else:
|
||||
model_label = f"{model} ({ctx_size})"
|
||||
|
||||
# Context % with color
|
||||
if ctx_pct >= 90:
|
||||
ctx_color = "\033[31m"
|
||||
elif ctx_pct >= 70:
|
||||
ctx_color = "\033[33m"
|
||||
else:
|
||||
ctx_color = "\033[32m"
|
||||
|
||||
# Build info line: model · ctx · branch · duration · dev · tasks [· rate limits]
|
||||
parts = [
|
||||
model_label,
|
||||
f"ctx {ctx_color}{ctx_pct}%\033[0m",
|
||||
]
|
||||
if branch:
|
||||
parts.append(f"\033[35m{branch}\033[0m")
|
||||
parts.append(duration)
|
||||
if dev:
|
||||
parts.append(f"\033[32m{dev}\033[0m")
|
||||
if task_count:
|
||||
parts.append(f"{task_count} task(s)")
|
||||
|
||||
five_hr = cc_data.get("rate_limits", {}).get("five_hour", {}).get("used_percentage")
|
||||
if five_hr is not None:
|
||||
parts.append(f"5h {int(five_hr)}%")
|
||||
seven_day = cc_data.get("rate_limits", {}).get("seven_day", {}).get("used_percentage")
|
||||
if seven_day is not None:
|
||||
parts.append(f"7d {int(seven_day)}%")
|
||||
|
||||
info_line = SEP.join(parts)
|
||||
|
||||
# Output: task line (only if active) + info line
|
||||
if task:
|
||||
print(f"\033[36m[{task['priority']}]\033[0m {task['title']} \033[33m({task['status']})\033[0m")
|
||||
print(info_line)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
34
.cursor/skills/trellis-before-dev/SKILL.md
Normal file
34
.cursor/skills/trellis-before-dev/SKILL.md
Normal file
@@ -0,0 +1,34 @@
|
||||
---
|
||||
name: trellis-before-dev
|
||||
description: "Discovers and injects project-specific coding guidelines from .trellis/spec/ before implementation begins. Reads spec indexes, pre-development checklists, and shared thinking guides for the target package. Use when starting a new coding task, before writing any code, switching to a different package, or needing to refresh project conventions and standards."
|
||||
---
|
||||
|
||||
Read the relevant development guidelines before starting your task.
|
||||
|
||||
Execute these steps:
|
||||
|
||||
1. **Discover packages and their spec layers**:
|
||||
```bash
|
||||
python3 ./.trellis/scripts/get_context.py --mode packages
|
||||
```
|
||||
|
||||
2. **Identify which specs apply** to your task based on:
|
||||
- Which package you're modifying (e.g., `cli/`, `docs-site/`)
|
||||
- What type of work (backend, frontend, unit-test, docs, etc.)
|
||||
|
||||
3. **Read the spec index** for each relevant module:
|
||||
```bash
|
||||
cat .trellis/spec/<package>/<layer>/index.md
|
||||
```
|
||||
Follow the **"Pre-Development Checklist"** section in the index.
|
||||
|
||||
4. **Read the specific guideline files** listed in the Pre-Development Checklist that are relevant to your task. The index is NOT the goal — it points you to the actual guideline files (e.g., `error-handling.md`, `conventions.md`, `mock-strategies.md`). Read those files to understand the coding standards and patterns.
|
||||
|
||||
5. **Always read shared guides**:
|
||||
```bash
|
||||
cat .trellis/spec/guides/index.md
|
||||
```
|
||||
|
||||
6. Understand the coding standards and patterns you need to follow, then proceed with your development plan.
|
||||
|
||||
This step is **mandatory** before writing any code.
|
||||
535
.cursor/skills/trellis-brainstorm/SKILL.md
Normal file
535
.cursor/skills/trellis-brainstorm/SKILL.md
Normal file
@@ -0,0 +1,535 @@
|
||||
---
|
||||
name: trellis-brainstorm
|
||||
description: "Guides collaborative requirements discovery before implementation. Creates task directory, seeds PRD, asks high-value questions one at a time, researches technical choices, and converges on MVP scope. Use when requirements are unclear, there are multiple valid approaches, or the user describes a new feature or complex task."
|
||||
---
|
||||
|
||||
# Brainstorm - Requirements Discovery (AI Coding Enhanced)
|
||||
|
||||
Guide AI through collaborative requirements discovery **before implementation**, optimized for AI coding workflows:
|
||||
|
||||
* **Task-first** (capture ideas immediately)
|
||||
* **Action-before-asking** (reduce low-value questions)
|
||||
* **Research-first** for technical choices (avoid asking users to invent options)
|
||||
* **Diverge → Converge** (expand thinking, then lock MVP)
|
||||
|
||||
---
|
||||
|
||||
## When to Use
|
||||
|
||||
Triggered from /trellis-start when the user describes a development task, especially when:
|
||||
|
||||
* requirements are unclear or evolving
|
||||
* there are multiple valid implementation paths
|
||||
* trade-offs matter (UX, reliability, maintainability, cost, performance)
|
||||
* the user might not know the best options up front
|
||||
|
||||
---
|
||||
|
||||
## Core Principles (Non-negotiable)
|
||||
|
||||
1. **Task-first (capture early)**
|
||||
Always ensure a task exists at the start so the user's ideas are recorded immediately.
|
||||
|
||||
2. **Action before asking**
|
||||
If you can derive the answer from repo code, docs, configs, conventions, or quick research — do that first.
|
||||
|
||||
3. **One question per message**
|
||||
Never overwhelm the user with a list of questions. Ask one, update PRD, repeat.
|
||||
|
||||
4. **Prefer concrete options**
|
||||
For preference/decision questions, present 2–3 feasible, specific approaches with trade-offs.
|
||||
|
||||
5. **Research-first for technical choices**
|
||||
If the decision depends on industry conventions / similar tools / established patterns, do research first, then propose options.
|
||||
|
||||
6. **Diverge → Converge**
|
||||
After initial understanding, proactively consider future evolution, related scenarios, and failure/edge cases — then converge to an MVP with explicit out-of-scope.
|
||||
|
||||
7. **No meta questions**
|
||||
Do not ask "should I search?" or "can you paste the code so I can continue?"
|
||||
If you need information: search/inspect. If blocked: ask the minimal blocking question.
|
||||
|
||||
---
|
||||
|
||||
## Step 0: Ensure Task Exists (ALWAYS)
|
||||
|
||||
Before any Q&A, ensure a task exists. If none exists, create one immediately.
|
||||
|
||||
* Use a **temporary working title** derived from the user's message.
|
||||
* It's OK if the title is imperfect — refine later in PRD.
|
||||
|
||||
```bash
|
||||
TASK_DIR=$(python3 ./.trellis/scripts/task.py create "brainstorm: <short goal>" --slug <auto>)
|
||||
```
|
||||
|
||||
Create/seed `prd.md` immediately with what you know:
|
||||
|
||||
```markdown
|
||||
# brainstorm: <short goal>
|
||||
|
||||
## Goal
|
||||
|
||||
<one paragraph: what + why>
|
||||
|
||||
## What I already know
|
||||
|
||||
* <facts from user message>
|
||||
* <facts discovered from repo/docs>
|
||||
|
||||
## Assumptions (temporary)
|
||||
|
||||
* <assumptions to validate>
|
||||
|
||||
## Open Questions
|
||||
|
||||
* <ONLY Blocking / Preference questions; keep list short>
|
||||
|
||||
## Requirements (evolving)
|
||||
|
||||
* <start with what is known>
|
||||
|
||||
## Acceptance Criteria (evolving)
|
||||
|
||||
* [ ] <testable criterion>
|
||||
|
||||
## Definition of Done (team quality bar)
|
||||
|
||||
* Tests added/updated (unit/integration where appropriate)
|
||||
* Lint / typecheck / CI green
|
||||
* Docs/notes updated if behavior changes
|
||||
* Rollout/rollback considered if risky
|
||||
|
||||
## Out of Scope (explicit)
|
||||
|
||||
* <what we will not do in this task>
|
||||
|
||||
## Technical Notes
|
||||
|
||||
* <files inspected, constraints, links, references>
|
||||
* <research notes summary if applicable>
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Step 1: Auto-Context (DO THIS BEFORE ASKING QUESTIONS)
|
||||
|
||||
Before asking questions like "what does the code look like?", gather context yourself:
|
||||
|
||||
### Repo inspection checklist
|
||||
|
||||
* Identify likely modules/files impacted
|
||||
* Locate existing patterns (similar features, conventions, error handling style)
|
||||
* Check configs, scripts, existing command definitions
|
||||
* Note any constraints (runtime, dependency policy, build tooling)
|
||||
|
||||
### Documentation checklist
|
||||
|
||||
* Look for existing PRDs/specs/templates
|
||||
* Look for command usage examples, README, ADRs if any
|
||||
|
||||
Write findings into PRD:
|
||||
|
||||
* Add to `What I already know`
|
||||
* Add constraints/links to `Technical Notes`
|
||||
|
||||
---
|
||||
|
||||
## Step 2: Classify Complexity (still useful, not gating task creation)
|
||||
|
||||
| Complexity | Criteria | Action |
|
||||
| ------------ | ------------------------------------------------------ | ------------------------------------------- |
|
||||
| **Trivial** | Single-line fix, typo, obvious change | Skip brainstorm, implement directly |
|
||||
| **Simple** | Clear goal, 1–2 files, scope well-defined | Ask 1 confirm question, then implement |
|
||||
| **Moderate** | Multiple files, some ambiguity | Light brainstorm (2–3 high-value questions) |
|
||||
| **Complex** | Vague goal, architectural choices, multiple approaches | Full brainstorm |
|
||||
|
||||
> Note: Task already exists from Step 0. Classification only affects depth of brainstorming.
|
||||
|
||||
---
|
||||
|
||||
## Step 3: Question Gate (Ask ONLY high-value questions)
|
||||
|
||||
Before asking ANY question, run the following gate:
|
||||
|
||||
### Gate A — Can I derive this without the user?
|
||||
|
||||
If answer is available via:
|
||||
|
||||
* repo inspection (code/config)
|
||||
* docs/specs/conventions
|
||||
* quick market/OSS research
|
||||
|
||||
→ **Do not ask.** Fetch it, summarize, update PRD.
|
||||
|
||||
### Gate B — Is this a meta/lazy question?
|
||||
|
||||
Examples:
|
||||
|
||||
* "Should I search?"
|
||||
* "Can you paste the code so I can proceed?"
|
||||
* "What does the code look like?" (when repo is available)
|
||||
|
||||
→ **Do not ask.** Take action.
|
||||
|
||||
### Gate C — What type of question is it?
|
||||
|
||||
* **Blocking**: cannot proceed without user input
|
||||
* **Preference**: multiple valid choices, depends on product/UX/risk preference
|
||||
* **Derivable**: should be answered by inspection/research
|
||||
|
||||
→ Only ask **Blocking** or **Preference**.
|
||||
|
||||
---
|
||||
|
||||
## Step 4: Research-first Mode (Mandatory for technical choices)
|
||||
|
||||
### Trigger conditions (any → research-first)
|
||||
|
||||
* The task involves selecting an approach, library, protocol, framework, template system, plugin mechanism, or CLI UX convention
|
||||
* The user asks for "best practice", "how others do it", "recommendation"
|
||||
* The user can't reasonably enumerate options
|
||||
|
||||
### Delegate to `trellis-research` sub-agent (don't research inline)
|
||||
|
||||
For each research topic, **spawn a `trellis-research` sub-agent via the Task tool** — don't do WebFetch / WebSearch / `gh api` inline in the main conversation.
|
||||
|
||||
Why:
|
||||
- The sub-agent has its own context window → doesn't pollute brainstorm context with raw tool output
|
||||
- It persists findings to `{TASK_DIR}/research/<topic>.md` (the contract — see `workflow.md` Phase 1.2)
|
||||
- It returns only `{file path, one-line summary}` to the main agent
|
||||
- Independent topics can be **parallelized** — spawn multiple sub-agents in one tool call
|
||||
|
||||
Agent type: `trellis-research`
|
||||
Task description template: "Research <specific question>; persist findings to `{TASK_DIR}/research/<topic-slug>.md`."
|
||||
|
||||
❌ Bad (what you must NOT do):
|
||||
```
|
||||
Main agent: WebFetch(url-A) → WebFetch(url-B) → Bash(gh api ...)
|
||||
→ WebSearch(q1) → WebSearch(q2) → ... (10+ inline calls)
|
||||
→ Write(research/topic.md)
|
||||
```
|
||||
→ Pollutes main context with raw HTML/JSON, burns tokens.
|
||||
|
||||
✅ Good:
|
||||
```
|
||||
Main agent: Task(subagent_type="trellis-research",
|
||||
prompt="Research topic A; persist to research/topic-a.md")
|
||||
+ Task(subagent_type="trellis-research",
|
||||
prompt="Research topic B; persist to research/topic-b.md")
|
||||
+ Task(subagent_type="trellis-research",
|
||||
prompt="Research topic C; persist to research/topic-c.md")
|
||||
→ Reads research/topic-{a,b,c}.md after they finish.
|
||||
```
|
||||
|
||||
### Research steps (to pass into each sub-agent prompt)
|
||||
|
||||
Each `trellis-research` sub-agent should:
|
||||
|
||||
1. Identify 2–4 comparable tools/patterns for its topic
|
||||
2. Summarize common conventions and why they exist
|
||||
3. Map conventions onto our repo constraints
|
||||
4. Write findings to `{TASK_DIR}/research/<topic>.md`
|
||||
|
||||
Main agent then reads the persisted files and produces **2–3 feasible approaches** in PRD.
|
||||
|
||||
### Research output format (PRD)
|
||||
|
||||
The PRD itself should only reference the persisted research files, not duplicate their content. Add a `## Research References` section pointing at `research/*.md`.
|
||||
|
||||
Optionally, add a convergence section with feasible approaches derived from the research:
|
||||
|
||||
```markdown
|
||||
## Research References
|
||||
|
||||
* [`research/<topic-a>.md`](research/<topic-a>.md) — <one-line takeaway>
|
||||
* [`research/<topic-b>.md`](research/<topic-b>.md) — <one-line takeaway>
|
||||
|
||||
## Research Notes
|
||||
|
||||
### What similar tools do
|
||||
|
||||
* ...
|
||||
* ...
|
||||
|
||||
### Constraints from our repo/project
|
||||
|
||||
* ...
|
||||
|
||||
### Feasible approaches here
|
||||
|
||||
**Approach A: <name>** (Recommended)
|
||||
|
||||
* How it works:
|
||||
* Pros:
|
||||
* Cons:
|
||||
|
||||
**Approach B: <name>**
|
||||
|
||||
* How it works:
|
||||
* Pros:
|
||||
* Cons:
|
||||
|
||||
**Approach C: <name>** (optional)
|
||||
|
||||
* ...
|
||||
```
|
||||
|
||||
Then ask **one** preference question:
|
||||
|
||||
* "Which approach do you prefer: A / B / C (or other)?"
|
||||
|
||||
---
|
||||
|
||||
## Step 5: Expansion Sweep (DIVERGE) — Required after initial understanding
|
||||
|
||||
After you can summarize the goal, proactively broaden thinking before converging.
|
||||
|
||||
### Expansion categories (keep to 1–2 bullets each)
|
||||
|
||||
1. **Future evolution**
|
||||
|
||||
* What might this feature become in 1–3 months?
|
||||
* What extension points are worth preserving now?
|
||||
|
||||
2. **Related scenarios**
|
||||
|
||||
* What adjacent commands/flows should remain consistent with this?
|
||||
* Are there parity expectations (create vs update, import vs export, etc.)?
|
||||
|
||||
3. **Failure & edge cases**
|
||||
|
||||
* Conflicts, offline/network failure, retries, idempotency, compatibility, rollback
|
||||
* Input validation, security boundaries, permission checks
|
||||
|
||||
### Expansion message template (to user)
|
||||
|
||||
```markdown
|
||||
I understand you want to implement: <current goal>.
|
||||
|
||||
Before diving into design, let me quickly diverge to consider three categories (to avoid rework later):
|
||||
|
||||
1. Future evolution: <1–2 bullets>
|
||||
2. Related scenarios: <1–2 bullets>
|
||||
3. Failure/edge cases: <1–2 bullets>
|
||||
|
||||
For this MVP, which would you like to include (or none)?
|
||||
|
||||
1. Current requirement only (minimal viable)
|
||||
2. Add <X> (reserve for future extension)
|
||||
3. Add <Y> (improve robustness/consistency)
|
||||
4. Other: describe your preference
|
||||
```
|
||||
|
||||
Then update PRD:
|
||||
|
||||
* What's in MVP → `Requirements`
|
||||
* What's excluded → `Out of Scope`
|
||||
|
||||
---
|
||||
|
||||
## Step 6: Q&A Loop (CONVERGE)
|
||||
|
||||
### Rules
|
||||
|
||||
* One question per message
|
||||
* Prefer multiple-choice when possible
|
||||
* After each user answer:
|
||||
|
||||
* Update PRD immediately
|
||||
* Move answered items from `Open Questions` → `Requirements`
|
||||
* Update `Acceptance Criteria` with testable checkboxes
|
||||
* Clarify `Out of Scope`
|
||||
|
||||
### Question priority (recommended)
|
||||
|
||||
1. **MVP scope boundary** (what is included/excluded)
|
||||
2. **Preference decisions** (after presenting concrete options)
|
||||
3. **Failure/edge behavior** (only for MVP-critical paths)
|
||||
4. **Success metrics & Acceptance Criteria** (what proves it works)
|
||||
|
||||
### Preferred question format (multiple choice)
|
||||
|
||||
```markdown
|
||||
For <topic>, which approach do you prefer?
|
||||
|
||||
1. **Option A** — <what it means + trade-off>
|
||||
2. **Option B** — <what it means + trade-off>
|
||||
3. **Option C** — <what it means + trade-off>
|
||||
4. **Other** — describe your preference
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Step 7: Propose Approaches + Record Decisions (Complex tasks)
|
||||
|
||||
After requirements are clear enough, propose 2–3 approaches (if not already done via research-first):
|
||||
|
||||
```markdown
|
||||
Based on current information, here are 2–3 feasible approaches:
|
||||
|
||||
**Approach A: <name>** (Recommended)
|
||||
|
||||
* How:
|
||||
* Pros:
|
||||
* Cons:
|
||||
|
||||
**Approach B: <name>**
|
||||
|
||||
* How:
|
||||
* Pros:
|
||||
* Cons:
|
||||
|
||||
Which direction do you prefer?
|
||||
```
|
||||
|
||||
Record the outcome in PRD as an ADR-lite section:
|
||||
|
||||
```markdown
|
||||
## Decision (ADR-lite)
|
||||
|
||||
**Context**: Why this decision was needed
|
||||
**Decision**: Which approach was chosen
|
||||
**Consequences**: Trade-offs, risks, potential future improvements
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Step 8: Final Confirmation + Implementation Plan
|
||||
|
||||
When open questions are resolved, confirm complete requirements with a structured summary:
|
||||
|
||||
### Final confirmation format
|
||||
|
||||
```markdown
|
||||
Here's my understanding of the complete requirements:
|
||||
|
||||
**Goal**: <one sentence>
|
||||
|
||||
**Requirements**:
|
||||
|
||||
* ...
|
||||
* ...
|
||||
|
||||
**Acceptance Criteria**:
|
||||
|
||||
* [ ] ...
|
||||
* [ ] ...
|
||||
|
||||
**Definition of Done**:
|
||||
|
||||
* ...
|
||||
|
||||
**Out of Scope**:
|
||||
|
||||
* ...
|
||||
|
||||
**Technical Approach**:
|
||||
<brief summary + key decisions>
|
||||
|
||||
**Implementation Plan (small PRs)**:
|
||||
|
||||
* PR1: <scaffolding + tests + minimal plumbing>
|
||||
* PR2: <core behavior>
|
||||
* PR3: <edge cases + docs + cleanup>
|
||||
|
||||
Does this look correct? If yes, I'll proceed with implementation.
|
||||
```
|
||||
|
||||
### Subtask Decomposition (Complex Tasks)
|
||||
|
||||
For complex tasks with multiple independent work items, create subtasks:
|
||||
|
||||
```bash
|
||||
# Create child tasks
|
||||
CHILD1=$(python3 ./.trellis/scripts/task.py create "Child task 1" --slug child1 --parent "$TASK_DIR")
|
||||
CHILD2=$(python3 ./.trellis/scripts/task.py create "Child task 2" --slug child2 --parent "$TASK_DIR")
|
||||
|
||||
# Or link existing tasks
|
||||
python3 ./.trellis/scripts/task.py add-subtask "$TASK_DIR" "$CHILD_DIR"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PRD Target Structure (final)
|
||||
|
||||
`prd.md` should converge to:
|
||||
|
||||
```markdown
|
||||
# <Task Title>
|
||||
|
||||
## Goal
|
||||
|
||||
<why + what>
|
||||
|
||||
## Requirements
|
||||
|
||||
* ...
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
* [ ] ...
|
||||
|
||||
## Definition of Done
|
||||
|
||||
* ...
|
||||
|
||||
## Technical Approach
|
||||
|
||||
<key design + decisions>
|
||||
|
||||
## Decision (ADR-lite)
|
||||
|
||||
Context / Decision / Consequences
|
||||
|
||||
## Out of Scope
|
||||
|
||||
* ...
|
||||
|
||||
## Technical Notes
|
||||
|
||||
<constraints, references, files, research notes>
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Anti-Patterns (Hard Avoid)
|
||||
|
||||
* Asking user for code/context that can be derived from repo
|
||||
* Asking user to choose an approach before presenting concrete options
|
||||
* Meta questions about whether to research
|
||||
* Staying narrowly on the initial request without considering evolution/edges
|
||||
* Letting brainstorming drift without updating PRD
|
||||
|
||||
---
|
||||
|
||||
## Integration with Start Workflow
|
||||
|
||||
After brainstorm completes (Step 8 confirmation approved), the flow continues to the Task Workflow's **Phase 2: Prepare for Implementation**:
|
||||
|
||||
```text
|
||||
Brainstorm
|
||||
Step 0: Create task directory + seed PRD
|
||||
Step 1–7: Discover requirements, research, converge
|
||||
Step 8: Final confirmation → user approves
|
||||
↓
|
||||
Task Workflow Phase 2 (Prepare for Implementation)
|
||||
Code-Spec Depth Check (if applicable)
|
||||
→ Research codebase (based on confirmed PRD)
|
||||
→ Configure code-spec context (jsonl files)
|
||||
→ Activate task
|
||||
↓
|
||||
Task Workflow Phase 3 (Execute)
|
||||
Implement → Check → Complete
|
||||
```
|
||||
|
||||
The task directory and PRD already exist from brainstorm, so Phase 1 of the Task Workflow is skipped entirely.
|
||||
|
||||
---
|
||||
|
||||
## Related Commands
|
||||
|
||||
| Command | When to Use |
|
||||
|---------|-------------|
|
||||
| `/trellis-start` | Entry point that triggers brainstorm |
|
||||
| `/trellis-finish-work` | After implementation is complete |
|
||||
| `/trellis-update-spec` | If new patterns emerge during work |
|
||||
130
.cursor/skills/trellis-break-loop/SKILL.md
Normal file
130
.cursor/skills/trellis-break-loop/SKILL.md
Normal file
@@ -0,0 +1,130 @@
|
||||
---
|
||||
name: trellis-break-loop
|
||||
description: "Deep bug analysis to break the fix-forget-repeat cycle. Analyzes root cause category, why fixes failed, prevention mechanisms, and captures knowledge into specs. Use after fixing a bug to prevent the same class of bugs."
|
||||
---
|
||||
|
||||
# Break the Loop - Deep Bug Analysis
|
||||
|
||||
When debug is complete, use this for deep analysis to break the "fix bug -> forget -> repeat" cycle.
|
||||
|
||||
---
|
||||
|
||||
## Analysis Framework
|
||||
|
||||
Analyze the bug you just fixed from these 5 dimensions:
|
||||
|
||||
### 1. Root Cause Category
|
||||
|
||||
Which category does this bug belong to?
|
||||
|
||||
| Category | Characteristics | Example |
|
||||
|----------|-----------------|---------|
|
||||
| **A. Missing Spec** | No documentation on how to do it | New feature without checklist |
|
||||
| **B. Cross-Layer Contract** | Interface between layers unclear | API returns different format than expected |
|
||||
| **C. Change Propagation Failure** | Changed one place, missed others | Changed function signature, missed call sites |
|
||||
| **D. Test Coverage Gap** | Unit test passes, integration fails | Works alone, breaks when combined |
|
||||
| **E. Implicit Assumption** | Code relies on undocumented assumption | Timestamp seconds vs milliseconds |
|
||||
|
||||
### 2. Why Fixes Failed (if applicable)
|
||||
|
||||
If you tried multiple fixes before succeeding, analyze each failure:
|
||||
|
||||
- **Surface Fix**: Fixed symptom, not root cause
|
||||
- **Incomplete Scope**: Found root cause, didn't cover all cases
|
||||
- **Tool Limitation**: grep missed it, type check wasn't strict
|
||||
- **Mental Model**: Kept looking in same layer, didn't think cross-layer
|
||||
|
||||
### 3. Prevention Mechanisms
|
||||
|
||||
What mechanisms would prevent this from happening again?
|
||||
|
||||
| Type | Description | Example |
|
||||
|------|-------------|---------|
|
||||
| **Documentation** | Write it down so people know | Update thinking guide |
|
||||
| **Architecture** | Make the error impossible structurally | Type-safe wrappers |
|
||||
| **Compile-time** | Strict type checking, no escape hatches | Signature change causes compile error |
|
||||
| **Runtime** | Monitoring, alerts, scans | Detect orphan entities |
|
||||
| **Test Coverage** | E2E tests, integration tests | Verify full flow |
|
||||
| **Code Review** | Checklist, PR template | "Did you check X?" |
|
||||
|
||||
### 4. Systematic Expansion
|
||||
|
||||
What broader problems does this bug reveal?
|
||||
|
||||
- **Similar Issues**: Where else might this problem exist?
|
||||
- **Design Flaw**: Is there a fundamental architecture issue?
|
||||
- **Process Flaw**: Is there a development process improvement?
|
||||
- **Knowledge Gap**: Is the team missing some understanding?
|
||||
|
||||
### 5. Knowledge Capture
|
||||
|
||||
Solidify insights into the system:
|
||||
|
||||
- [ ] Update `.trellis/spec/guides/` thinking guides
|
||||
- [ ] Update relevant `.trellis/spec/` docs
|
||||
- [ ] Create issue record (if applicable)
|
||||
- [ ] Create feature ticket for root fix
|
||||
- [ ] Update check guidelines if needed
|
||||
|
||||
---
|
||||
|
||||
## Output Format
|
||||
|
||||
Please output analysis in this format:
|
||||
|
||||
```markdown
|
||||
## Bug Analysis: [Short Description]
|
||||
|
||||
### 1. Root Cause Category
|
||||
- **Category**: [A/B/C/D/E] - [Category Name]
|
||||
- **Specific Cause**: [Detailed description]
|
||||
|
||||
### 2. Why Fixes Failed (if applicable)
|
||||
1. [First attempt]: [Why it failed]
|
||||
2. [Second attempt]: [Why it failed]
|
||||
...
|
||||
|
||||
### 3. Prevention Mechanisms
|
||||
| Priority | Mechanism | Specific Action | Status |
|
||||
|----------|-----------|-----------------|--------|
|
||||
| P0 | ... | ... | TODO/DONE |
|
||||
|
||||
### 4. Systematic Expansion
|
||||
- **Similar Issues**: [List places with similar problems]
|
||||
- **Design Improvement**: [Architecture-level suggestions]
|
||||
- **Process Improvement**: [Development process suggestions]
|
||||
|
||||
### 5. Knowledge Capture
|
||||
- [ ] [Documents to update / tickets to create]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Core Philosophy
|
||||
|
||||
> **The value of debugging is not in fixing the bug, but in making this class of bugs never happen again.**
|
||||
|
||||
Three levels of insight:
|
||||
1. **Tactical**: How to fix THIS bug
|
||||
2. **Strategic**: How to prevent THIS CLASS of bugs
|
||||
3. **Philosophical**: How to expand thinking patterns
|
||||
|
||||
30 minutes of analysis saves 30 hours of future debugging.
|
||||
|
||||
---
|
||||
|
||||
## After Analysis: Immediate Actions
|
||||
|
||||
**IMPORTANT**: After completing the analysis above, you MUST immediately:
|
||||
|
||||
1. **Update spec/guides** - Don't just list TODOs, actually update the relevant files:
|
||||
- If it's a cross-platform issue → update `cross-platform-thinking-guide.md`
|
||||
- If it's a cross-layer issue → update `cross-layer-thinking-guide.md`
|
||||
- If it's a code reuse issue → update `code-reuse-thinking-guide.md`
|
||||
- If it's domain-specific → update `backend/*.md` or `frontend/*.md`
|
||||
|
||||
2. **Sync templates** - After updating `.trellis/spec/`, sync to `src/templates/markdown/spec/`
|
||||
|
||||
3. **Commit the spec updates** - This is the primary output, not just the analysis text
|
||||
|
||||
> **The analysis is worthless if it stays in chat. The value is in the updated specs.**
|
||||
92
.cursor/skills/trellis-check/SKILL.md
Normal file
92
.cursor/skills/trellis-check/SKILL.md
Normal file
@@ -0,0 +1,92 @@
|
||||
---
|
||||
name: trellis-check
|
||||
description: "Comprehensive quality verification: spec compliance, lint, type-check, tests, cross-layer data flow, code reuse, and consistency checks. Use when code is written and needs quality verification, before committing changes, or to catch context drift during long sessions."
|
||||
---
|
||||
|
||||
# Code Quality Check
|
||||
|
||||
Comprehensive quality verification for recently written code. Combines spec compliance, cross-layer safety, and pre-commit checks.
|
||||
|
||||
---
|
||||
|
||||
## Step 1: Identify What Changed
|
||||
|
||||
```bash
|
||||
git diff --name-only HEAD
|
||||
git status
|
||||
```
|
||||
|
||||
## Step 2: Read Applicable Specs
|
||||
|
||||
```bash
|
||||
python3 ./.trellis/scripts/get_context.py --mode packages
|
||||
```
|
||||
|
||||
For each changed package/layer, read the spec index and follow its **Quality Check** section:
|
||||
|
||||
```bash
|
||||
cat .trellis/spec/<package>/<layer>/index.md
|
||||
```
|
||||
|
||||
Read the specific guideline files referenced — the index is a pointer, not the goal.
|
||||
|
||||
## Step 3: Run Project Checks
|
||||
|
||||
Run the project's lint, type-check, and test commands. Fix any failures before proceeding.
|
||||
|
||||
## Step 4: Review Against Checklist
|
||||
|
||||
### Code Quality
|
||||
|
||||
- [ ] Linter passes?
|
||||
- [ ] Type checker passes (if applicable)?
|
||||
- [ ] Tests pass?
|
||||
- [ ] No debug logging left in?
|
||||
- [ ] No suppressed warnings or type-safety bypasses?
|
||||
|
||||
### Test Coverage
|
||||
|
||||
- [ ] New function → unit test added?
|
||||
- [ ] Bug fix → regression test added?
|
||||
- [ ] Changed behavior → existing tests updated?
|
||||
|
||||
### Spec Sync
|
||||
|
||||
- [ ] Does `.trellis/spec/` need updates? (new patterns, conventions, lessons learned)
|
||||
|
||||
> "If I fixed a bug or discovered something non-obvious, should I document it so future me won't hit the same issue?" → If YES, update the relevant spec doc.
|
||||
|
||||
## Step 5: Cross-Layer Dimensions (if applicable)
|
||||
|
||||
Skip this step if your change is confined to a single layer.
|
||||
|
||||
### A. Data Flow (changes touch 3+ layers)
|
||||
|
||||
- [ ] Read flow traces correctly: Storage → Service → API → UI
|
||||
- [ ] Write flow traces correctly: UI → API → Service → Storage
|
||||
- [ ] Types/schemas correctly passed between layers?
|
||||
- [ ] Errors properly propagated to caller?
|
||||
|
||||
### B. Code Reuse (modifying constants, creating utilities)
|
||||
|
||||
- [ ] Searched for existing similar code before creating new?
|
||||
```bash
|
||||
grep -r "pattern" src/
|
||||
```
|
||||
- [ ] If 2+ places define same value → extracted to shared constant?
|
||||
- [ ] After batch modification, all occurrences updated?
|
||||
|
||||
### C. Import/Dependency (creating new files)
|
||||
|
||||
- [ ] Correct import paths (relative vs absolute)?
|
||||
- [ ] No circular dependencies?
|
||||
|
||||
### D. Same-Layer Consistency
|
||||
|
||||
- [ ] Other places using the same concept are consistent?
|
||||
|
||||
---
|
||||
|
||||
## Step 6: Report and Fix
|
||||
|
||||
Report violations found and fix them directly. Re-run project checks after fixes.
|
||||
356
.cursor/skills/trellis-update-spec/SKILL.md
Normal file
356
.cursor/skills/trellis-update-spec/SKILL.md
Normal file
@@ -0,0 +1,356 @@
|
||||
---
|
||||
name: trellis-update-spec
|
||||
description: "Captures executable contracts and coding conventions into .trellis/spec/ documents. Use when learning something valuable from debugging, implementing, or discussion that should be preserved for future sessions."
|
||||
---
|
||||
|
||||
# Update Code-Spec - Capture Executable Contracts
|
||||
|
||||
When you learn something valuable (from debugging, implementing, or discussion), use this to update the relevant code-spec documents.
|
||||
|
||||
**Timing**: After completing a task, fixing a bug, or discovering a new pattern
|
||||
|
||||
---
|
||||
|
||||
## Code-Spec First Rule (CRITICAL)
|
||||
|
||||
In this project, "spec" for implementation work means **code-spec**:
|
||||
- Executable contracts (not principle-only text)
|
||||
- Concrete signatures, payload fields, env keys, and boundary behavior
|
||||
- Testable validation/error behavior
|
||||
|
||||
If the change touches infra or cross-layer contracts, code-spec depth is mandatory.
|
||||
|
||||
### Mandatory Triggers
|
||||
|
||||
Apply code-spec depth when the change includes any of:
|
||||
- New/changed command or API signature
|
||||
- Cross-layer request/response contract change
|
||||
- Database schema/migration change
|
||||
- Infra integration (storage, queue, cache, secrets, env wiring)
|
||||
|
||||
### Mandatory Output (7 Sections)
|
||||
|
||||
For triggered tasks, include all sections below:
|
||||
1. Scope / Trigger
|
||||
2. Signatures (command/API/DB)
|
||||
3. Contracts (request/response/env)
|
||||
4. Validation & Error Matrix
|
||||
5. Good/Base/Bad Cases
|
||||
6. Tests Required (with assertion points)
|
||||
7. Wrong vs Correct (at least one pair)
|
||||
|
||||
---
|
||||
|
||||
## When to Update Code-Specs
|
||||
|
||||
| Trigger | Example | Target Spec |
|
||||
|---------|---------|-------------|
|
||||
| **Implemented a feature** | Added a new integration or module | Relevant spec file |
|
||||
| **Made a design decision** | Chose extensibility pattern over simplicity | Relevant spec + "Design Decisions" section |
|
||||
| **Fixed a bug** | Found a subtle issue with error handling | Relevant spec (e.g., error-handling docs) |
|
||||
| **Discovered a pattern** | Found a better way to structure code | Relevant spec file |
|
||||
| **Hit a gotcha** | Learned that X must be done before Y | Relevant spec + "Common Mistakes" section |
|
||||
| **Established a convention** | Team agreed on naming pattern | Quality guidelines |
|
||||
| **New thinking trigger** | "Don't forget to check X before doing Y" | `guides/*.md` (as a checklist item) |
|
||||
|
||||
**Key Insight**: Code-spec updates are NOT just for problems. Every feature implementation contains design decisions and contracts that future AI/developers need to execute safely.
|
||||
|
||||
---
|
||||
|
||||
## Spec Structure Overview
|
||||
|
||||
```
|
||||
.trellis/spec/
|
||||
├── <layer>/ # Per-layer coding standards (e.g., backend/, frontend/, api/)
|
||||
│ ├── index.md # Overview and links
|
||||
│ └── *.md # Topic-specific guidelines
|
||||
└── guides/ # Thinking checklists (NOT coding specs!)
|
||||
├── index.md # Guide index
|
||||
└── *.md # Topic-specific guides
|
||||
```
|
||||
|
||||
### CRITICAL: Code-Spec vs Guide - Know the Difference
|
||||
|
||||
| Type | Location | Purpose | Content Style |
|
||||
|------|----------|---------|---------------|
|
||||
| **Code-Spec** | `<layer>/*.md` | Tell AI "how to implement safely" | Signatures, contracts, matrices, cases, test points |
|
||||
| **Guide** | `guides/*.md` | Help AI "what to think about" | Checklists, questions, pointers to specs |
|
||||
|
||||
**Decision Rule**: Ask yourself:
|
||||
|
||||
- "This is **how to write** the code" → Put in a spec layer directory
|
||||
- "This is **what to consider** before writing" → Put in `guides/`
|
||||
|
||||
**Example**:
|
||||
|
||||
| Learning | Wrong Location | Correct Location |
|
||||
|----------|----------------|------------------|
|
||||
| "Use API X not API Y for this task" | ❌ `guides/` (too specific for a thinking guide) | ✅ Relevant spec file (concrete convention) |
|
||||
| "Remember to check X when doing Y" | ❌ Spec file (too abstract for a spec) | ✅ `guides/` (thinking checklist) |
|
||||
|
||||
**Guides should be short checklists that point to specs**, not duplicate the detailed rules.
|
||||
|
||||
---
|
||||
|
||||
## Update Process
|
||||
|
||||
### Step 1: Identify What You Learned
|
||||
|
||||
Answer these questions:
|
||||
|
||||
1. **What did you learn?** (Be specific)
|
||||
2. **Why is it important?** (What problem does it prevent?)
|
||||
3. **Where does it belong?** (Which spec file?)
|
||||
|
||||
### Step 2: Classify the Update Type
|
||||
|
||||
| Type | Description | Action |
|
||||
|------|-------------|--------|
|
||||
| **Design Decision** | Why we chose approach X over Y | Add to "Design Decisions" section |
|
||||
| **Project Convention** | How we do X in this project | Add to relevant section with examples |
|
||||
| **New Pattern** | A reusable approach discovered | Add to "Patterns" section |
|
||||
| **Forbidden Pattern** | Something that causes problems | Add to "Anti-patterns" or "Don't" section |
|
||||
| **Common Mistake** | Easy-to-make error | Add to "Common Mistakes" section |
|
||||
| **Convention** | Agreed-upon standard | Add to relevant section |
|
||||
| **Gotcha** | Non-obvious behavior | Add warning callout |
|
||||
|
||||
### Step 3: Read the Target Code-Spec
|
||||
|
||||
Before editing, read the current code-spec to:
|
||||
- Understand existing structure
|
||||
- Avoid duplicating content
|
||||
- Find the right section for your update
|
||||
|
||||
```bash
|
||||
cat .trellis/spec/<category>/<file>.md
|
||||
```
|
||||
|
||||
### Step 4: Make the Update
|
||||
|
||||
Follow these principles:
|
||||
|
||||
1. **Be Specific**: Include concrete examples, not just abstract rules
|
||||
2. **Explain Why**: State the problem this prevents
|
||||
3. **Show Contracts**: Add signatures, payload fields, and error behavior
|
||||
4. **Show Code**: Add code snippets for key patterns
|
||||
5. **Keep it Short**: One concept per section
|
||||
|
||||
### Step 5: Update the Index (if needed)
|
||||
|
||||
If you added a new section or the code-spec status changed, update the category's `index.md`.
|
||||
|
||||
---
|
||||
|
||||
## Update Templates
|
||||
|
||||
### Mandatory Template for Infra/Cross-Layer Work
|
||||
|
||||
```markdown
|
||||
## Scenario: <name>
|
||||
|
||||
### 1. Scope / Trigger
|
||||
- Trigger: <why this requires code-spec depth>
|
||||
|
||||
### 2. Signatures
|
||||
- Backend command/API/DB signature(s)
|
||||
|
||||
### 3. Contracts
|
||||
- Request fields (name, type, constraints)
|
||||
- Response fields (name, type, constraints)
|
||||
- Environment keys (required/optional)
|
||||
|
||||
### 4. Validation & Error Matrix
|
||||
- <condition> -> <error>
|
||||
|
||||
### 5. Good/Base/Bad Cases
|
||||
- Good: ...
|
||||
- Base: ...
|
||||
- Bad: ...
|
||||
|
||||
### 6. Tests Required
|
||||
- Unit/Integration/E2E with assertion points
|
||||
|
||||
### 7. Wrong vs Correct
|
||||
#### Wrong
|
||||
...
|
||||
#### Correct
|
||||
...
|
||||
```
|
||||
|
||||
### Adding a Design Decision
|
||||
|
||||
```markdown
|
||||
### Design Decision: [Decision Name]
|
||||
|
||||
**Context**: What problem were we solving?
|
||||
|
||||
**Options Considered**:
|
||||
1. Option A - brief description
|
||||
2. Option B - brief description
|
||||
|
||||
**Decision**: We chose Option X because...
|
||||
|
||||
**Example**:
|
||||
\`\`\`typescript
|
||||
// How it's implemented
|
||||
code example
|
||||
\`\`\`
|
||||
|
||||
**Extensibility**: How to extend this in the future...
|
||||
```
|
||||
|
||||
### Adding a Project Convention
|
||||
|
||||
```markdown
|
||||
### Convention: [Convention Name]
|
||||
|
||||
**What**: Brief description of the convention.
|
||||
|
||||
**Why**: Why we do it this way in this project.
|
||||
|
||||
**Example**:
|
||||
\`\`\`typescript
|
||||
// How to follow this convention
|
||||
code example
|
||||
\`\`\`
|
||||
|
||||
**Related**: Links to related conventions or specs.
|
||||
```
|
||||
|
||||
### Adding a New Pattern
|
||||
|
||||
```markdown
|
||||
### Pattern Name
|
||||
|
||||
**Problem**: What problem does this solve?
|
||||
|
||||
**Solution**: Brief description of the approach.
|
||||
|
||||
**Example**:
|
||||
\`\`\`
|
||||
// Good
|
||||
code example
|
||||
|
||||
// Bad
|
||||
code example
|
||||
\`\`\`
|
||||
|
||||
**Why**: Explanation of why this works better.
|
||||
```
|
||||
|
||||
### Adding a Forbidden Pattern
|
||||
|
||||
```markdown
|
||||
### Don't: Pattern Name
|
||||
|
||||
**Problem**:
|
||||
\`\`\`
|
||||
// Don't do this
|
||||
bad code example
|
||||
\`\`\`
|
||||
|
||||
**Why it's bad**: Explanation of the issue.
|
||||
|
||||
**Instead**:
|
||||
\`\`\`
|
||||
// Do this instead
|
||||
good code example
|
||||
\`\`\`
|
||||
```
|
||||
|
||||
### Adding a Common Mistake
|
||||
|
||||
```markdown
|
||||
### Common Mistake: Description
|
||||
|
||||
**Symptom**: What goes wrong
|
||||
|
||||
**Cause**: Why this happens
|
||||
|
||||
**Fix**: How to correct it
|
||||
|
||||
**Prevention**: How to avoid it in the future
|
||||
```
|
||||
|
||||
### Adding a Gotcha
|
||||
|
||||
```markdown
|
||||
> **Warning**: Brief description of the non-obvious behavior.
|
||||
>
|
||||
> Details about when this happens and how to handle it.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Interactive Mode
|
||||
|
||||
If you're unsure what to update, answer these prompts:
|
||||
|
||||
1. **What did you just finish?**
|
||||
- [ ] Fixed a bug
|
||||
- [ ] Implemented a feature
|
||||
- [ ] Refactored code
|
||||
- [ ] Had a discussion about approach
|
||||
|
||||
2. **What did you learn or decide?**
|
||||
- Design decision (why X over Y)
|
||||
- Project convention (how we do X)
|
||||
- Non-obvious behavior (gotcha)
|
||||
- Better approach (pattern)
|
||||
|
||||
3. **Would future AI/developers need to know this?**
|
||||
- To understand how the code works → Yes, update spec
|
||||
- To maintain or extend the feature → Yes, update spec
|
||||
- To avoid repeating mistakes → Yes, update spec
|
||||
- Purely one-off implementation detail → Maybe skip
|
||||
|
||||
4. **Which area does it relate to?**
|
||||
- [ ] Backend code
|
||||
- [ ] Frontend code
|
||||
- [ ] Cross-layer data flow
|
||||
- [ ] Code organization/reuse
|
||||
- [ ] Quality/testing
|
||||
|
||||
---
|
||||
|
||||
## Quality Checklist
|
||||
|
||||
Before finishing your code-spec update:
|
||||
|
||||
- [ ] Is the content specific and actionable?
|
||||
- [ ] Did you include a code example?
|
||||
- [ ] Did you explain WHY, not just WHAT?
|
||||
- [ ] Did you include executable signatures/contracts?
|
||||
- [ ] Did you include validation and error matrix?
|
||||
- [ ] Did you include Good/Base/Bad cases?
|
||||
- [ ] Did you include required tests with assertion points?
|
||||
- [ ] Is it in the right code-spec file?
|
||||
- [ ] Does it duplicate existing content?
|
||||
- [ ] Would a new team member understand it?
|
||||
|
||||
---
|
||||
|
||||
## Relationship to Other Commands
|
||||
|
||||
```
|
||||
Development Flow:
|
||||
Learn something → /trellis-update-spec → Knowledge captured
|
||||
↑ ↓
|
||||
/trellis-break-loop ←──────────────────── Future sessions benefit
|
||||
(deep bug analysis)
|
||||
```
|
||||
|
||||
- `/trellis-break-loop` - Analyzes bugs deeply, often reveals spec updates needed
|
||||
- `/trellis-update-spec` - Actually makes the updates
|
||||
- `/trellis-finish-work` - Reminds you to check if specs need updates
|
||||
|
||||
---
|
||||
|
||||
## Core Philosophy
|
||||
|
||||
> **Code-specs are living documents. Every debugging session, every "aha moment" is an opportunity to make the implementation contract clearer.**
|
||||
|
||||
The goal is **institutional memory**:
|
||||
- What one person learns, everyone benefits from
|
||||
- What AI learns in one session, persists to future sessions
|
||||
- Mistakes become documented guardrails
|
||||
Reference in New Issue
Block a user