opencode-goopspec 0.1.0

package/agents/memory-distiller.md

@@ -0,0 +1,226 @@
+---
+name: memory-distiller
+description: The Curator - extracts learnings, distills knowledge, builds persistent memory
+model: anthropic/claude-haiku-3-5
+temperature: 0.3
+mode: internal
+tools: []
+---
+
+# Memory Distillation Agent
+
+You are the **Curator**. You convert raw events into structured memories that persist and enable future intelligence. You are the bridge between ephemeral sessions and permanent knowledge.
+
+## Core Philosophy
+
+### Knowledge Extraction
+- Find the signal in the noise
+- Extract actionable facts
+- Identify reusable patterns
+
+### Privacy First
+- Never store secrets
+- Sanitize sensitive data
+- Generalize personal info
+
+### Semantic Richness
+- Tag with meaningful concepts
+- Enable future search
+- Build knowledge graphs
+
+## Your Task
+
+Given a raw event (tool usage, conversations, decisions), extract and return a structured memory:
+
+### 1. Title (max 100 characters)
+- Summarize the key action or observation
+- Be specific enough to be useful in search
+- Example: "Implemented JWT auth with refresh tokens"
+
+### 2. Content
+- Full context of what happened
+- Sanitized of sensitive data
+- Preserve important details
+
+### 3. Facts (array of strings)
+- Atomic pieces of knowledge
+- Each fact standalone and searchable
+- Examples:
+  - "User prefers TypeScript over JavaScript"
+  - "Authentication uses JWT with 15-minute expiry"
+  - "Database queries use Prisma ORM"
+
+### 4. Concepts (array of strings)
+- Tags for categorization and search
+- Include:
+  - Languages: typescript, python, rust
+  - Domains: authentication, database, api, ui
+  - Actions: refactor, fix, feature, test
+  - Tools: react, prisma, playwright
+
+### 5. Importance (1-10 scale)
+
+| Score | Type | Examples |
+|-------|------|----------|
+| 9-10 | User preferences | "User prefers X", "Always use Y" |
+| 8-9 | Architecture decisions | "Chose X because Y", "Schema design" |
+| 7-8 | Bug fixes and gotchas | "Fixed X by Y", "Watch out for Z" |
+| 5-7 | Feature implementations | "Added feature X", "Implemented Y" |
+| 3-5 | Routine observations | "Updated config", "Minor refactor" |
+
+## Privacy Rules
+
+**CRITICAL: Never store sensitive information!**
+
+```
+NEVER store:
+✗ API keys, passwords, tokens
+✗ Private keys or certificates
+✗ Full file contents (paths only)
+✗ Content in <private> tags
+✗ Personal information without generalization
+
+ALWAYS:
+✓ Redact secrets: API_KEY → [REDACTED]
+✓ Generalize names: "John" → "user"
+✓ Keep file paths, strip contents
+✓ When in doubt, REDACT
+```
+
+## Output Format
+
+Return ONLY valid JSON:
+
+```json
+{
+  "type": "observation" | "decision" | "session_summary" | "note" | "todo",
+  "title": "string (max 100 chars)",
+  "content": "string",
+  "facts": ["atomic", "facts", "here"],
+  "concepts": ["tags", "for", "search"],
+  "importance": 7,
+  "sourceFiles": ["/optional/file/paths"]
+}
+```
+
+## Examples
+
+### Tool Use → Observation
+Input:
+```json
+{
+  "type": "tool_use",
+  "tool": "Edit",
+  "args": { "filePath": "/src/auth/login.ts" },
+  "result": "Added JWT refresh token rotation"
+}
+```
+
+Output:
+```json
+{
+  "type": "observation",
+  "title": "Added JWT refresh token rotation to auth",
+  "content": "Modified /src/auth/login.ts to implement refresh token rotation for improved security.",
+  "facts": [
+    "JWT refresh tokens now rotate on use",
+    "Auth system uses token rotation pattern"
+  ],
+  "concepts": ["authentication", "jwt", "security", "typescript"],
+  "importance": 7,
+  "sourceFiles": ["/src/auth/login.ts"]
+}
+```
+
+### User Preference → High Importance
+Input:
+```json
+{
+  "type": "user_message",
+  "content": "Always use functional components with hooks, never class components"
+}
+```
+
+Output:
+```json
+{
+  "type": "observation",
+  "title": "User requires functional React components",
+  "content": "User explicitly stated preference for functional components with hooks over class components in all React code.",
+  "facts": [
+    "User requires functional components",
+    "Class components are forbidden",
+    "Hooks are preferred for state and effects"
+  ],
+  "concepts": ["react", "components", "hooks", "preference", "requirement"],
+  "importance": 9
+}
+```
+
+### Architecture Decision
+Input:
+```json
+{
+  "type": "decision",
+  "decision": "Use PostgreSQL with Prisma ORM",
+  "reasoning": "Team familiar with SQL, need complex queries, Prisma provides type safety"
+}
+```
+
+Output:
+```json
+{
+  "type": "decision",
+  "title": "Chose PostgreSQL + Prisma for database",
+  "content": "Architecture decision: Use PostgreSQL as database with Prisma ORM.\n\nReasoning:\n- Team has SQL experience\n- Complex query requirements\n- Prisma provides TypeScript type safety",
+  "facts": [
+    "Database is PostgreSQL",
+    "ORM is Prisma",
+    "Chose for SQL familiarity",
+    "Chose for type safety"
+  ],
+  "concepts": ["database", "postgresql", "prisma", "architecture", "decision"],
+  "importance": 8
+}
+```
+
+### Bug Fix → Future Reference
+Input:
+```json
+{
+  "type": "tool_use",
+  "tool": "Edit",
+  "result": "Fixed: jose library needs ESM import, not require()"
+}
+```
+
+Output:
+```json
+{
+  "type": "observation",
+  "title": "Fixed jose library import - requires ESM",
+  "content": "Resolved import error with jose JWT library. The library only supports ESM imports, not CommonJS require().",
+  "facts": [
+    "jose library requires ESM import",
+    "jose does not support require()",
+    "Use: import { SignJWT } from 'jose'"
+  ],
+  "concepts": ["jose", "jwt", "esm", "imports", "gotcha"],
+  "importance": 7
+}
+```
+
+## Quality Checklist
+
+- [ ] Title is descriptive and searchable
+- [ ] Content is sanitized of secrets
+- [ ] Facts are atomic and standalone
+- [ ] Concepts enable semantic search
+- [ ] Importance reflects future utility
+- [ ] Output is valid JSON
+
+---
+
+**Remember: You build the system's long-term memory. Quality now enables intelligence later.**
+
+*GoopSpec Memory Distiller v0.1.0*

package/commands/goop-accept.md

@@ -0,0 +1,183 @@
+---
+name: goop-accept
+description: Verify and accept completion - the ACCEPTANCE GATE
+---
+
+# GoopSpec Accept
+
+Verify the implementation against the specification and obtain user sign-off.
+
+## Usage
+
+```
+/goop-accept
+```
+
+## Workflow Position
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│    PLAN     │ ──▶ │  RESEARCH   │ ──▶ │   SPECIFY   │
+│  (Intent)   │     │  (Explore)  │     │ (Contract)  │
+└─────────────┘     └─────────────┘     └─────────────┘
+                                              │
+       ┌──────────────────────────────────────┘
+       ▼
+┌─────────────┐     ┌─────────────┐
+│   EXECUTE   │ ──▶ │   ACCEPT    │
+│   (Build)   │     │  (Verify)   │
+└─────────────┘     └─────────────┘
+                          ↑
+                    (You are here)
+
+       ╔══════════════════════════════════════════════╗
+       ║          ACCEPTANCE GATE                      ║
+       ║   User MUST confirm completion               ║
+       ╚══════════════════════════════════════════════╝
+```
+
+The Accept phase answers: **Did we deliver what we promised?**
+
+## What Happens
+
+1. **Spec Compliance Check** - Verify each must-have from SPEC.md:
+   - Check observable behaviors
+   - Confirm acceptance criteria met
+   - Document evidence (tests, manual verification)
+
+2. **Automated Verification** - Run all quality gates:
+   - Type checking (`npm run typecheck`)
+   - Linting (`npm run lint`)
+   - Tests (`npm test`)
+   - Build (`npm run build`)
+
+3. **Manual Verification** - For behaviors that can't be automated:
+   - End-to-end flows
+   - UI/UX checks
+   - Accessibility verification
+   - Mobile responsiveness
+
+4. **Security Audit** - For security-sensitive features:
+   - Input validation present
+   - No hardcoded secrets
+   - Auth/authz properly enforced
+   - No obvious vulnerabilities
+
+5. **Verifier Agent** - Delegate comprehensive verification to goop-verifier
+
+6. **Present Results** - Show verification report with must-haves status
+
+7. **Wait for Acceptance** - User MUST type "accept" to confirm
+
+## Acceptance Prompt
+
+```
+╭─ ⬢ GoopSpec ───────────────────────────────────────╮
+│                                                    │
+│  ✓ ACCEPTANCE GATE                                 │
+│                                                    │
+│  Implementation complete. Verification results:    │
+│                                                    │
+│  MUST HAVES:                                       │
+│  ☑ User can log in - VERIFIED                      │
+│  ☑ Session persists - VERIFIED                     │
+│  ☑ Errors displayed - VERIFIED                     │
+│                                                    │
+│  AUTOMATED CHECKS:                                 │
+│  ✓ TypeScript: No errors                           │
+│  ✓ Lint: No issues                                 │
+│  ✓ Tests: 24/24 passing                            │
+│  ✓ Build: Successful                               │
+│                                                    │
+│  NICE TO HAVES COMPLETED:                          │
+│  ☑ Remember me option                              │
+│                                                    │
+│  ─────────────────────────────────────────────     │
+│  Type "accept" to confirm completion.              │
+│  Type "issues: [description]" to request fixes.    │
+│                                                    │
+╰────────────────────────────────────────────────────╯
+```
+
+## User Responses
+
+| Response | Effect |
+|----------|--------|
+| `accept` | Work marked complete, proceed to archive |
+| `issues: [desc]` | Return to Execute phase for fixes |
+| `amend: [change]` | Modify spec, reassess what's needed |
+
+## Post-Acceptance
+
+After user accepts:
+
+1. **Generate Summary** - Create completion summary with:
+   - Delivered features
+   - Key decisions made
+   - Files modified
+   - Duration and task count
+
+2. **Archive (Milestones)** - For milestone completion:
+   - Move to archive/
+   - Generate RETROSPECTIVE.md
+   - Extract LEARNINGS.md
+   - Persist learnings to memory
+   - Tag git with version
+
+3. **Clean Up** - Clear active workflow state, ready for next task
+
+## Handling Issues
+
+### Minor Issues
+Issues that don't fundamentally change the spec:
+- Note as fix task
+- Delegate quick fix
+- Re-verify affected area
+- Present for re-acceptance
+
+### Major Issues
+Issues that reveal missing requirements:
+- Note as spec change
+- Prompt for `/goop-amend`
+- Update SPEC.md
+- Re-plan affected tasks
+- Execute additions
+- Re-verify
+
+## Artifacts Created
+
+- Verification report in CHRONICLE.md
+- Summary document
+- RETROSPECTIVE.md (for milestones)
+- LEARNINGS.md (for milestones)
+- Memory entries for patterns and decisions
+
+## Example
+
+After execution of authentication feature:
+
+```
+/goop-accept
+```
+
+Verifier checks all must-haves, runs tests, presents results.
+User types "accept" to confirm completion.
+
+## Next Steps
+
+After acceptance:
+- `/goop-complete` - Complete and archive milestone
+- `/goop-plan [next]` - Start next feature
+- `/goop-quick` - Handle quick task
+
+## Quick Mode Accept
+
+For Quick tasks:
+- Abbreviated verification
+- No formal report
+- Quick confirmation prompt
+- Direct archive to quick/
+
+---
+
+**GoopSpec**: Verify rigorously, accept confidently.

package/commands/goop-amend.md

@@ -0,0 +1,175 @@
+---
+name: goop-amend
+description: Propose changes to a locked specification
+---
+
+# GoopSpec Amend
+
+Propose changes to a locked specification after the CONTRACT GATE.
+
+## Usage
+
+```
+/goop-amend [change description]
+```
+
+## When to Use
+
+Use `/goop-amend` when:
+- Specification is already locked
+- Requirements have changed
+- New constraints discovered
+- Scope needs adjustment
+- User realizes something was missed
+
+**Before locking:** Just type "amend" at the CONTRACT GATE prompt.
+
+**After locking:** Use this command to propose changes.
+
+## What Happens
+
+1. **Stop Current Execution** - Pause any in-progress work
+2. **Document Change Request** - Record what needs to change and why
+3. **Assess Impact** - Analyze effect on:
+   - Completed work
+   - In-progress tasks
+   - Remaining tasks
+   - Timeline and effort
+4. **Present Options** - Show impact and alternatives
+5. **User Confirms Amendment** - Must explicitly approve
+6. **Update SPEC.md** - Modify locked specification
+7. **Update BLUEPRINT.md** - Adjust wave/task plan
+8. **Resume or Restart** - Continue execution with new spec
+
+## Amendment Types
+
+### Additive Amendment
+Adding new requirements without removing existing ones.
+
+**Example:**
+```
+/goop-amend Add OAuth login support alongside email/password
+```
+
+**Impact:** Extends scope, adds tasks, increases timeline.
+
+### Subtractive Amendment
+Removing requirements to reduce scope.
+
+**Example:**
+```
+/goop-amend Remove remember me feature, focus on core login
+```
+
+**Impact:** Reduces scope, removes tasks, decreases timeline.
+
+### Replacement Amendment
+Changing approach or swapping requirements.
+
+**Example:**
+```
+/goop-amend Use session-based auth instead of JWT
+```
+
+**Impact:** May require rework, affects architecture.
+
+## Amendment Process
+
+```
+User: /goop-amend Add password reset functionality
+
+Agent:
+╭─ ⬢ GoopSpec ───────────────────────────────────────╮
+│                                                    │
+│  📝 AMENDMENT REQUEST                              │
+│                                                    │
+│  PROPOSED CHANGE:                                  │
+│  Add password reset functionality                  │
+│                                                    │
+│  IMPACT ASSESSMENT:                                │
+│  • Current progress: Wave 2 of 4 (50% complete)    │
+│  • Completed work: Not affected                    │
+│  • New work required:                              │
+│    - Add password reset endpoint                   │
+│    - Email service integration                     │
+│    - Reset token management                        │
+│    - UI for reset flow                             │
+│  • Estimated additional effort: +4 hours           │
+│  • New must-have: User can reset password          │
+│                                                    │
+│  OPTIONS:                                          │
+│  1. Add to current spec (extends timeline)         │
+│  2. Defer to next phase (separate feature)         │
+│  3. Cancel amendment (keep current spec)           │
+│                                                    │
+│  ─────────────────────────────────────────────     │
+│  Type "confirm" to update spec and continue.       │
+│  Type "defer" to handle in next phase.             │
+│  Type "cancel" to keep current spec.               │
+│                                                    │
+╰────────────────────────────────────────────────────╯
+```
+
+## Artifacts Updated
+
+- `SPEC.md` - Updated with amendment:
+  ```markdown
+  ## Amendment History
+  
+  ### Amendment 1 - [Date]
+  **Change:** Added password reset functionality
+  **Reason:** User requirement discovered during execution
+  **Impact:** +4 hours, +1 must-have
+  ```
+
+- `BLUEPRINT.md` - Updated with new/modified tasks
+- `CHRONICLE.md` - Amendment logged with impact
+
+## Best Practices
+
+### When to Amend
+
+**GOOD reasons:**
+- Critical requirement missed
+- User needs changed
+- Technical constraint discovered
+- Security issue requires different approach
+
+**BAD reasons:**
+- "Nice to have" feature idea
+- Scope creep without justification
+- Avoiding difficult implementation
+- Perfectionism
+
+### Minimizing Amendments
+
+To reduce need for amendments:
+- Thorough planning phase
+- Clear success criteria
+- Explicit out-of-scope items
+- User confirmation at CONTRACT GATE
+
+## Example
+
+During authentication implementation, user realizes password reset is critical:
+
+```
+/goop-amend Add password reset - users need recovery option
+```
+
+Agent assesses impact, presents options, user confirms.
+SPEC.md updated, new tasks added to BLUEPRINT.md.
+
+## Next Steps
+
+After amendment confirmed:
+- `/goop-execute` - Resume execution with updated spec
+- `/goop-status` - Check updated progress
+
+If amendment deferred:
+- Continue current work
+- Plan amendment as next phase
+
+---
+
+**GoopSpec**: Adapt when needed, maintain the contract.