opencodekit 0.17.1 → 0.17.2

package/dist/template/.opencode/command/init-context.md

@@ -0,0 +1,259 @@
+---
+description: Initialize GSD-style project planning context with integrated skill usage
+argument-hint: "[--skip-questions] [--brownfield]"
+agent: build
+---
+
+# Init-Context: $ARGUMENTS
+
+Initialize GSD-style project planning with integrated skill usage.
+
+## Load Skills
+
+```typescript
+skill({ name: "context-initialization" });
+skill({ name: "brainstorming" });
+skill({ name: "verification-before-completion" });
+```
+
+## Parse Arguments
+
+```typescript
+const args = {
+  skipQuestions: $ARGUMENTS.includes("--skip-questions"),
+  brownfield: $ARGUMENTS.includes("--brownfield"),
+  focus: $ARGUMENTS.match(/--focus=(\w+)/)?.[1], // Optional: api, ui, db, etc.
+};
+```
+
+## Phase 1: Discovery
+
+### 1.1 Check Existing Context
+
+```bash
+ls .opencode/memory/project/ 2>/dev/null && HAS_CONTEXT=true || HAS_CONTEXT=false
+cat .opencode/memory/project/project.md 2>/dev/null | head -20
+```
+
+**If context exists:**
+
+```
+Existing planning context found:
+- project.md: [exists/size]
+- roadmap.md: [exists/size]
+- state.md: [exists/size]
+
+Options:
+1. Refresh - Delete and recreate from templates
+2. Update - Keep existing, only update state.md
+3. Skip - Use existing context as-is
+```
+
+Wait for user selection.
+
+### 1.2 Brownfield Codebase Analysis (if --brownfield)
+
+If `--brownfield` flag is set:
+
+```typescript
+// Spawn parallel analysis agents (like GSD map-codebase)
+skill({ name: "swarm-coordination" });
+
+// Agent 1: Map tech stack
+Task({
+  subagent_type: "explore",
+  description: "Analyze tech stack",
+  prompt:
+    "Analyze the codebase technology stack. Write findings to .opencode/memory/project/tech-analysis.md covering: languages, frameworks, dependencies, build tools. Return file path and line count only.",
+});
+
+// Agent 2: Map architecture
+Task({
+  subagent_type: "explore",
+  description: "Analyze architecture",
+  prompt:
+    "Analyze the codebase architecture. Write findings to .opencode/memory/project/arch-analysis.md covering: patterns, directory structure, entry points. Return file path and line count only.",
+});
+
+// Wait for agents and collect confirmations
+```
+
+## Phase 2: Requirements Gathering
+
+### 2.1 Load Brainstorming Skill (if not --skip-questions)
+
+```typescript
+if (!args.skipQuestions) {
+  skill({ name: "brainstorming" });
+
+  // Follow brainstorming process for project vision
+  // Ask questions one at a time (as per brainstorming skill)
+  // Output: Refined vision, success criteria, target users
+}
+```
+
+### 2.2 Quick Mode (if --skip-questions)
+
+Use template defaults with placeholders for:
+
+- Project vision
+- Success criteria
+- Target users
+- Phases
+- Current phase
+
+## Phase 3: Document Creation
+
+### 3.1 Create project.md
+
+**Load template:**
+
+```bash
+cat .opencode/memory/_templates/project.md
+```
+
+**Fill with gathered data:**
+
+- Vision from brainstorming OR template placeholder
+- Success criteria (3-7 measurable outcomes)
+- Target users (primary/secondary)
+- Core principles (convention over config, minimal, extensible)
+- Current phase (from user input or template default)
+
+**Write to:** `.opencode/memory/project/project.md`
+
+### 3.2 Create roadmap.md
+
+**Parse phases from input:**
+
+```typescript
+// Convert user-provided phases into structured roadmap
+// Example: "Discovery, MVP, Launch, Scale" → table rows
+```
+
+**Structure:**
+
+```markdown
+| Phase     | Goal   | Status   | Beads |
+| --------- | ------ | -------- | ----- |
+| [Phase 1] | [Goal] | [Status] | [#]   |
+```
+
+**Write to:** `.opencode/memory/project/roadmap.md`
+
+### 3.3 Create state.md
+
+**Initialize with:**
+
+- Active Bead: (blank or from bead context)
+- Status: In Progress
+- Started: [current date]
+- Phase: [from roadmap]
+- Recent Completed Work: (empty table)
+- Active Decisions: (empty table)
+- Blockers: (empty table)
+- Open Questions: (empty table)
+- Next Actions: (empty list)
+
+**Write to:** `.opencode/memory/project/state.md`
+
+### 3.4 Brownfield Analysis Integration (if applicable)
+
+If `--brownfield` analysis was run:
+
+```typescript
+// Append tech/arch findings to project.md Context Notes section
+// Or create separate .opencode/memory/project/codebase/ documents
+// (similar to GSD's .planning/codebase/ approach)
+```
+
+## Phase 4: Verification & Security
+
+### 4.1 Verify Documents Created
+
+```bash
+ls -la .opencode/memory/project/
+wc -l .opencode/memory/project/*.md
+```
+
+**Check:**
+
+- [ ] project.md exists and >20 lines
+- [ ] roadmap.md exists and >20 lines
+- [ ] state.md exists and >20 lines
+- [ ] All files are readable
+
+### 4.2 Secret Scan (Critical - from GSD pattern)
+
+```bash
+# Scan for accidentally leaked secrets in generated docs
+grep -E '(sk-[a-zA-Z0-9]{20,}|sk_live_[a-zA-Z0-9]+|AKIA[A-Z0-9]{16}|ghp_[a-zA-Z0-9]{36}|-----BEGIN.*PRIVATE KEY)' .opencode/memory/project/*.md 2>/dev/null && SECRETS_FOUND=true || SECRETS_FOUND=false
+```
+
+**If secrets found:** Alert user and pause before proceeding.
+
+### 4.3 Load Verification Skill
+
+```typescript
+skill({ name: "verification-before-completion" });
+
+// Run verification checklist:
+// 1. IDENTIFY: Files created, structure valid
+// 2. RUN: Validation commands
+// 3. READ: Check file contents
+// 4. VERIFY: All success criteria met
+// 5. CLAIM: Context initialization complete
+```
+
+## Phase 5: Beads Integration
+
+### 5.1 Create Initialization Bead (optional)
+
+```bash
+# If user wants to track context setup as a bead
+br create "Initialize project context" --type=task
+br update <bead-id> --status closed --reason="Context files created"
+```
+
+## Output
+
+Creates in `.opencode/memory/project/`:
+
+| File         | Purpose                                  | Lines (typical) |
+| ------------ | ---------------------------------------- | --------------- |
+| `project.md` | Vision, success criteria, principles     | 50-100          |
+| `roadmap.md` | Phases, milestones, bead planning        | 80-150          |
+| `state.md`   | Current position, blockers, next actions | 60-100          |
+
+**If `--brownfield`:**
+Additional files in `.opencode/memory/project/codebase/`:
+
+- `tech-analysis.md` - Stack and dependencies
+- `arch-analysis.md` - Architecture patterns
+
+## Success Criteria
+
+- [ ] All required documents created from templates
+- [ ] Documents follow template structure
+- [ ] No secrets leaked in generated files
+- [ ] Files pass basic validation (readable, non-empty)
+- [ ] User informed of next steps
+
+## Next Steps
+
+After init-context completes:
+
+1. **For new projects:** Use `/plan` to create first implementation plan
+2. **For brownfield:** Review codebase analysis, then `/plan`
+3. **For existing beads:** Use `/resume` to continue tracked work
+
+---
+
+## Skill Integration Summary
+
+| Skill                            | When Used                         | Purpose                        |
+| -------------------------------- | --------------------------------- | ------------------------------ |
+| `brainstorming`                  | Phase 2 (if not --skip-questions) | Refine vision and requirements |
+| `swarm-coordination`             | Phase 1.2 (if --brownfield)       | Parallel codebase analysis     |
+| `verification-before-completion` | Phase 4                           | Validate created files         |
+| `beads`                          | Phase 5                           | Track as bead if desired       |

package/dist/template/.opencode/command/init-user.md

@@ -0,0 +1,103 @@
+---
+description: Create user profile for personalized AI interactions
+argument-hint: "[--skip-questions]"
+agent: build
+---
+
+# Init-User: $ARGUMENTS
+
+Create personalized user profile. Optional but recommended for better AI responses.
+
+> **Prerequisite:** Run `/init` first for core setup
+> **Related:** `/init-context` for project planning setup
+
+## Load Skills
+
+```typescript
+skill({ name: "memory-system" });
+```
+
+## Options
+
+| Argument           | Default | Description                         |
+| ------------------ | ------- | ----------------------------------- |
+| `--skip-questions` | false   | Infer from git config, skip prompts |
+
+## Phase 1: Gather Preferences
+
+Unless `--skip-questions`, ask in one message:
+
+1. **Identity**: "Which git contributor are you?" (show top 5 from `git shortlog -sn --all`)
+2. **Communication**: "Terse or detailed responses?"
+3. **Workflow**: "Auto-commit or ask-first?"
+4. **Rules**: "Any rules I should always follow?"
+5. **Technical**: "Preferred languages/frameworks?"
+
+If skipped, infer from `git config user.name` and `git config user.email`.
+
+## Phase 2: Create user.md
+
+From template `.opencode/memory/_templates/user.md`:
+
+```bash
+cp .opencode/memory/_templates/user.md .opencode/memory/project/user.md
+```
+
+Fill in gathered answers:
+
+```markdown
+---
+purpose: User identity, preferences, communication style
+updated: [today]
+---
+
+# User Profile
+
+## Identity
+
+- **Name:** [from answers]
+- **Git:** [user.name] <[user.email]>
+
+## Communication Preferences
+
+- **Style:** [Terse/Detailed]
+- **Tone:** [Professional/Casual]
+
+## Workflow Preferences
+
+- **Commits:** [Auto/Ask-first]
+- **Beads updates:** [Auto/Ask-first]
+
+## Technical Preferences
+
+- **Languages:** [Preferred languages]
+- **Frameworks:** [Preferred frameworks]
+
+## Rules to Always Follow
+
+- [Rule 1]
+- [Rule 2]
+- [Rule 3]
+```
+
+## Phase 3: Update opencode.json
+
+Ensure user.md is loaded in instructions:
+
+```json
+{
+  "instructions": [
+    "file://.opencode/AGENTS.md",
+    "file://.opencode/memory/project/tech-stack.md",
+    "file://.opencode/memory/project/user.md"
+  ]
+}
+```
+
+## Phase 4: Report
+
+Output:
+
+1. user.md created at `.opencode/memory/project/user.md`
+2. Preferences captured
+3. Next step: `/init-context` for GSD planning workflow

package/dist/template/.opencode/command/init.md

@@ -1,40 +1,28 @@
 ---
-description: Initialize project for AI-assisted development (creates AGENTS.md + memory files)
-argument-hint: "[--deep] [--skip-questions]"
+description: Initialize core project setup (AGENTS.md + tech-stack detection only)
+argument-hint: "[--deep]"
 agent: build
 ---
 
 # Init: $ARGUMENTS
 
-One command to onboard a project. Creates project-root AGENTS.md and populates memory files.
+Core project setup. Creates AGENTS.md and detects tech stack. Run once per project.
+
+> **Next steps:** `/init-user` for personalization, `/init-context` for GSD planning workflow
 
 ## Load Skills
 
 ```typescript
-skill({ name: "memory-system" });
 skill({ name: "index-knowledge" });
 ```
 
 ## Options
 
-| Argument           | Default | Description                               |
-| ------------------ | ------- | ----------------------------------------- |
-| `--deep`           | false   | Comprehensive research (~100+ tool calls) |
-| `--skip-questions` | false   | Infer from git config, skip prompts       |
-
-## Phase 1: Upfront Questions
-
-Unless `--skip-questions`, ask in one message:
-
-1. **Identity**: "Which git contributor are you?" (show top 5 from `git shortlog -sn --all`)
-2. **Communication**: "Terse or detailed responses?"
-3. **Workflow**: "Auto-commit or ask-first?"
-4. **Rules**: "Any rules I should always follow?"
-5. **Beads**: "Use beads for task tracking?"
-
-If skipped, infer identity from `git config user.name` and `git config user.email`.
+| Argument | Default | Description                               |
+| -------- | ------- | ----------------------------------------- |
+| `--deep` | false   | Comprehensive research (~100+ tool calls) |
 
-## Phase 2: Detect Project
+## Phase 1: Detect Project
 
 Detect and validate:
 
@@ -44,7 +32,29 @@ Detect and validate:
 - Existing AI rules (`.cursor/rules/`, `.cursorrules`, `.github/copilot-instructions.md`)
 - Top-level directory structure
 
-With `--deep`: Also analyze git history (contributors, commit conventions, branching strategy), source patterns, and subsystem candidates.
+With `--deep`: Also analyze git history, source patterns, subsystem candidates.
+
+## Phase 2: Preview Detection
+
+After detecting project, show summary and ask for confirmation:
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Preview",
+      question: `Detected: ${detectedTechStack}. Create AGENTS.md?`,
+      options: [
+        { label: "Yes, create it (Recommended)" },
+        { label: "Show me what you'll write first" },
+        { label: "Cancel" },
+      ],
+    },
+  ],
+});
+```
+
+**If "Show me":** Display detected values without writing files, then ask again.
 
 ## Phase 3: Create AGENTS.md
 
@@ -58,16 +68,23 @@ Create `./AGENTS.md` — **target <60 lines** (max 150). Follow the `index-knowl
 - Boundaries (always/ask-first/never)
 - Gotchas
 
-**Principles**: Examples > explanations. Pointers > copies. If AGENTS.md already exists, improve it — don't overwrite blindly.
+**Principles**: Examples > explanations. Pointers > copies. If AGENTS.md exists, improve it — don't overwrite blindly.
+
+## Phase 4: Create tech-stack.md
 
-## Phase 4: Populate Memory Files
+From template `.opencode/memory/_templates/tech-stack.md`:
 
-Read templates from `.opencode/memory/_templates/`, then create:
+```bash
+cp .opencode/memory/_templates/tech-stack.md .opencode/memory/project/tech-stack.md
+```
 
-- `.opencode/memory/project/user.md` — from Phase 1 answers
-- `.opencode/memory/project/tech-stack.md` — from Phase 2 detection
+Fill detected values:
 
-Use `write()` for markdown files on disk (not `memory-update()` which writes to SQLite).
+- Framework, language, runtime
+- Styling, components, design system
+- Database, ORM, state management
+- Testing tools
+- Verification commands
 
 ## Phase 5: Subsystems (--deep only)
 
@@ -79,25 +96,22 @@ Identify candidates for nested AGENTS.md:
 
 Ask user before creating nested files.
 
-## Phase 6: Initialize Beads (if requested)
-
-```bash
-br init
-```
-
-## Phase 7: Verify and Report
+## Phase 6: Verify and Report
 
 Verify:
 
-- [ ] AGENTS.md is <60 lines (or justified if longer)
+- [ ] AGENTS.md is <60 lines (or justified)
 - [ ] Commands validated and work
 - [ ] Boundaries include Never rules
-- [ ] At least one code example from actual codebase
-- [ ] Memory files created with accurate info
+- [ ] Code example from actual codebase
+- [ ] tech-stack.md created
 
 Output:
 
 1. Files created (with line counts)
 2. Tech stack detected
 3. Commands validated (yes/no)
-4. Suggested next steps: review AGENTS.md, run `/review-codebase`
+4. Suggested next steps:
+   - `/init-user` — Create user profile
+   - `/init-context` — Set up GSD planning workflow
+   - `/review-codebase` — Deep codebase analysis