glitchcode-cli 0.1.1

package/src/skill/compose/.bundle/review/code-reviewer.md

@@ -0,0 +1,171 @@
+# Code Reviewer Prompt Template
+
+Use this template when dispatching a code reviewer subagent.
+
+**Purpose:** Review completed work against requirements and code quality standards before it cascades into more work.
+
+Dispatch a `general` subagent via the `actor` tool, following the syntax in that
+tool's own description. Use a title like "Review code changes" with this prompt:
+
+~~~
+    You are a Senior Code Reviewer with expertise in software architecture,
+    design patterns, and best practices. Your job is to review completed work
+    against its plan or requirements and identify issues before they cascade.
+
+    ## What Was Implemented
+
+    {DESCRIPTION}
+
+    ## Requirements / Plan
+
+    {PLAN_OR_REQUIREMENTS}
+
+    ## Git Range to Review
+
+    **Base:** {BASE_SHA}
+    **Head:** {HEAD_SHA}
+
+    ```bash
+    git diff --stat {BASE_SHA}..{HEAD_SHA}
+    git diff {BASE_SHA}..{HEAD_SHA}
+    ```
+
+    ## What to Check
+
+    **Plan alignment:**
+    - Does the implementation match the plan / requirements?
+    - Are deviations justified improvements, or problematic departures?
+    - Is all planned functionality present?
+    - If the plan tasks carry `Covers: [Sn]` spec anchors, spot-check that each spec
+      section is realized somewhere in the change. Key any gap you find to its `[Sn]`
+      anchor so it traces back to the exact spec section.
+
+    **Code quality:**
+    - Clean separation of concerns?
+    - Proper error handling?
+    - Type safety where applicable?
+    - DRY without premature abstraction?
+    - Edge cases handled?
+
+    **Architecture:**
+    - Sound design decisions?
+    - Reasonable scalability and performance?
+    - Security concerns?
+    - Integrates cleanly with surrounding code?
+
+    **Testing:**
+    - Tests verify real behavior, not mocks?
+    - Edge cases covered?
+    - Integration tests where they matter?
+    - All tests passing?
+
+    **Production readiness:**
+    - Migration strategy if schema changed?
+    - Backward compatibility considered?
+    - Documentation complete?
+    - No obvious bugs?
+
+    ## Calibration
+
+    Categorize issues by actual severity. Not everything is Critical.
+    Acknowledge what was done well before listing issues — accurate praise
+    helps the implementer trust the rest of the feedback.
+
+    If you find significant deviations from the plan, flag them specifically
+    so the implementer can confirm whether the deviation was intentional.
+    If you find issues with the plan itself rather than the implementation,
+    say so.
+
+    ## Output Format
+
+    ### Strengths
+    [What's well done? Be specific.]
+
+    ### Issues
+
+    #### Critical (Must Fix)
+    [Bugs, security issues, data loss risks, broken functionality]
+
+    #### Important (Should Fix)
+    [Architecture problems, missing features, poor error handling, test gaps]
+
+    #### Minor (Nice to Have)
+    [Code style, optimization opportunities, documentation polish]
+
+    For each issue:
+    - File:line reference
+    - What's wrong
+    - Why it matters
+    - How to fix (if not obvious)
+
+    ### Recommendations
+    [Improvements for code quality, architecture, or process]
+
+    ### Assessment
+
+    **Ready to merge?** [Yes | No | With fixes]
+
+    **Reasoning:** [1-2 sentence technical assessment]
+
+    ## Critical Rules
+
+    **DO:**
+    - Categorize by actual severity
+    - Be specific (file:line, not vague)
+    - Explain WHY each issue matters
+    - Acknowledge strengths
+    - Give a clear verdict
+
+    **DON'T:**
+    - Say "looks good" without checking
+    - Mark nitpicks as Critical
+    - Give feedback on code you didn't actually read
+    - Be vague ("improve error handling")
+    - Avoid giving a clear verdict
+~~~
+
+**Placeholders:**
+- `{DESCRIPTION}` — brief summary of what was built
+- `{PLAN_OR_REQUIREMENTS}` — what it should do (plan file path, task text, or requirements)
+- `{BASE_SHA}` — starting commit
+- `{HEAD_SHA}` — ending commit
+
+**Reviewer returns:** Strengths, Issues (Critical / Important / Minor), Recommendations, Assessment
+
+## Example Output
+
+```
+### Strengths
+- Clean database schema with proper migrations (db.ts:15-42)
+- Comprehensive test coverage (18 tests, all edge cases)
+- Good error handling with fallbacks (summarizer.ts:85-92)
+
+### Issues
+
+#### Important
+1. **Missing help text in CLI wrapper**
+   - File: index-conversations:1-31
+   - Issue: No --help flag, users won't discover --concurrency
+   - Fix: Add --help case with usage examples
+
+2. **Date validation missing**
+   - File: search.ts:25-27
+   - Issue: Invalid dates silently return no results
+   - Fix: Validate ISO format, throw error with example
+
+#### Minor
+1. **Progress indicators**
+   - File: indexer.ts:130
+   - Issue: No "X of Y" counter for long operations
+   - Impact: Users don't know how long to wait
+
+### Recommendations
+- Add progress reporting for user experience
+- Consider config file for excluded projects (portability)
+
+### Assessment
+
+**Ready to merge: With fixes**
+
+**Reasoning:** Core implementation is solid with good architecture and tests. Important issues (help text, date validation) are easily fixed and don't affect core functionality.
+```

package/src/skill/compose/.bundle/self-extend/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: self-extend
+description: Use when you want to evolve your own capabilities — create new tools to avoid repeating patterns, add hooks to improve your own behavior, build skills to accumulate domain knowledge, or override built-in tools to adapt to project needs. This is your self-iteration interface.
+---
+
+# Self-Extension
+
+## Overview
+
+You can extend your own capabilities by writing files to `.mimocode/`. Changes to tools, hooks, and skills take effect immediately (next turn) — no restart needed.
+
+## Creating Tools
+
+Write to `.mimocode/tools/<name>.ts`:
+
+```ts
+import { tool } from "@mimo-ai/plugin"
+
+export default tool({
+  description: "What this tool does",
+  args: {
+    param1: tool.schema.string().describe("Parameter description"),
+  },
+  async execute(args, ctx) {
+    // ctx.directory — project root
+    // ctx.worktree — git worktree root
+    // ctx.abort — AbortSignal
+    return `Result: ${args.param1}`
+  },
+})
+```
+
+Multiple tools per file: use named exports instead of default.
+
+## Creating Hooks
+
+Write to `.mimocode/hooks/<name>.ts` — export a Hooks object:
+
+```ts
+export default {
+  "tool.execute.before": async (input, output) => {
+    if (input.tool === "bash" && output.args.command?.includes("rm -rf /")) {
+      output.cancel = true
+      output.cancelReason = "Blocked dangerous command"
+    }
+  },
+  "experimental.chat.system.transform": async (input, output) => {
+    output.system.push("Additional instruction here.")
+  },
+}
+```
+
+### Hook Events
+
+| Event | Capability |
+|-------|-----------|
+| `tool.execute.before` | Modify args or `cancel=true` to block |
+| `tool.execute.after` | Modify tool output |
+| `tool.definition` | Modify tool description/parameters |
+| `chat.params` | Modify temperature, topP, maxOutputTokens |
+| `experimental.chat.system.transform` | Append to system prompt |
+| `experimental.chat.messages.transform` | Modify message list sent to LLM |
+| `permission.ask` | Auto-allow/deny permission requests |
+| `shell.env` | Inject environment variables |
+
+## Tool Override
+
+A custom tool with the same id as a built-in replaces it:
+
+```ts
+// .mimocode/tools/bash.ts — overrides built-in bash
+import { tool } from "@mimo-ai/plugin"
+import { execSync } from "child_process"
+
+export default tool({
+  description: "Shell with safety checks",
+  args: { command: tool.schema.string() },
+  async execute(args, ctx) {
+    if (args.command.includes("sudo")) return "Error: sudo not allowed"
+    return execSync(args.command, { encoding: "utf-8", cwd: ctx.directory })
+  },
+})
+```
+
+## Creating Skills
+
+Write to `.mimocode/skills/<name>/SKILL.md`:
+
+```markdown
+---
+name: my-skill
+description: Use when [conditions]
+---
+Instructions here...
+```
+
+## File Locations
+
+| Type | Path | Hot-reload |
+|------|------|-----------|
+| Tools | `.mimocode/tools/*.ts` | next turn |
+| Hooks | `.mimocode/hooks/*.ts` | next turn |
+| Skills | `.mimocode/skills/*/SKILL.md` | next turn |
+| TUI | `.mimocode/tui/*.tsx` | restart |
+
+## When to Use What
+
+| I want to... | Use |
+|-------------|-----|
+| Wrap a repeated bash/API pattern | Tool |
+| Block or modify a tool's behavior | Hook (`tool.execute.before`) |
+| Inject context into system prompt | Hook (`chat.system.transform`) |
+| Accumulate domain knowledge for future use | Skill |
+| Override how a built-in tool works | Tool (same name as builtin) |
+| Add a custom UI panel or command | TUI plugin |
+
+## Detailed API Reference
+
+For full type signatures, all available fields, and more examples:
+
+- See @reference/tool-api.md for Tool schema and ToolContext
+- See @reference/hook-api.md for all hook events with input/output types
+- See @reference/skill-api.md for SKILL.md format and frontmatter fields
+- See @reference/tui-api.md for TUI plugin slots, commands, dialogs, and state
+
+## Constraints
+
+- Tools/hooks have same permissions as bash — no privilege escalation
+- Cannot modify the permission system
+- Tool output truncated at 50KB / 2000 lines
+- Prefer small, composable extensions over monolithic ones

package/src/skill/compose/.bundle/self-extend/reference/hook-api.md

@@ -0,0 +1,242 @@
+# Hook API Reference
+
+## File Format
+
+```ts
+import type { Hooks } from "@mimo-ai/plugin"
+
+const hooks: Hooks = {
+  "event.name": async (input, output) => {
+    // Mutate `output` to modify behavior
+  },
+}
+
+export default hooks
+```
+
+Each file exports a single Hooks object. Multiple events can be handled in one file.
+
+## Event Reference
+
+### tool.execute.before
+
+Fires before any tool executes. Can modify args or cancel.
+
+```ts
+"tool.execute.before": async (input, output) => {
+  // input (read-only):
+  //   input.tool: string      — tool id ("bash", "write", "edit", etc.)
+  //   input.sessionID: string
+  //   input.callID: string
+
+  // output (mutable):
+  //   output.args: any        — tool arguments, mutate to change
+  //   output.cancel?: boolean — set true to block execution
+  //   output.cancelReason?: string — shown to LLM as tool result
+}
+```
+
+### tool.execute.after
+
+Fires after tool execution. Can modify the result.
+
+```ts
+"tool.execute.after": async (input, output) => {
+  // input (read-only):
+  //   input.tool: string
+  //   input.sessionID: string
+  //   input.callID: string
+  //   input.args: any         — the args that were used
+
+  // output (mutable):
+  //   output.title: string
+  //   output.output: string   — the tool's text output
+  //   output.metadata: any
+}
+```
+
+### tool.definition
+
+Modify tool descriptions/parameters sent to LLM.
+
+```ts
+"tool.definition": async (input, output) => {
+  // input.toolID: string
+
+  // output (mutable):
+  //   output.description: string  — tool description
+  //   output.parameters: any      — JSON Schema for parameters
+}
+```
+
+### chat.params
+
+Modify LLM request parameters.
+
+```ts
+"chat.params": async (input, output) => {
+  // input (read-only):
+  //   input.sessionID: string
+  //   input.agent: string
+  //   input.model: Model
+  //   input.provider: ProviderContext
+
+  // output (mutable):
+  //   output.temperature: number
+  //   output.topP: number
+  //   output.topK: number
+  //   output.maxOutputTokens: number | undefined
+  //   output.options: Record<string, any>
+}
+```
+
+### chat.headers
+
+Add custom HTTP headers to LLM requests.
+
+```ts
+"chat.headers": async (input, output) => {
+  // input: same as chat.params
+  // output.headers: Record<string, string>  — mutate to add headers
+}
+```
+
+### experimental.chat.system.transform
+
+Modify the system prompt sent to LLM.
+
+```ts
+"experimental.chat.system.transform": async (input, output) => {
+  // input.sessionID?: string
+  // input.model: Model
+
+  // output.system: string[]  — array of system prompt sections
+  // Push to append, splice to insert, replace to override
+  output.system.push("Always respond concisely.")
+}
+```
+
+### experimental.chat.messages.transform
+
+Modify the message list sent to LLM.
+
+```ts
+"experimental.chat.messages.transform": async (input, output) => {
+  // output.messages: Array<{ info: Message, parts: Part[] }>
+  // Filter, reorder, or modify messages before they reach the model
+}
+```
+
+### permission.ask
+
+Auto-allow or deny permission requests.
+
+> **Note:** Defined in the Hooks interface but not yet wired in the permission system. Writing this hook is safe (no-op until upstream integrates it).
+
+```ts
+"permission.ask": async (input, output) => {
+  // input: Permission object (permission name, patterns, metadata)
+  // output.status: "ask" | "deny" | "allow"
+  
+  // Example: auto-allow all read operations
+  if (input.permission === "read") {
+    output.status = "allow"
+  }
+}
+```
+
+### shell.env
+
+Inject environment variables into shell execution.
+
+```ts
+"shell.env": async (input, output) => {
+  // input.cwd: string
+  // input.sessionID?: string
+  // output.env: Record<string, string>
+  
+  output.env.NODE_ENV = "development"
+  output.env.DEBUG = "true"
+}
+```
+
+### command.execute.before
+
+Inject content before a slash command runs.
+
+```ts
+"command.execute.before": async (input, output) => {
+  // input.command: string
+  // input.sessionID: string
+  // input.arguments: string
+  // output.parts: Part[]  — prepend parts to the command
+}
+```
+
+### experimental.session.compacting
+
+Customize the compaction prompt.
+
+```ts
+"experimental.session.compacting": async (input, output) => {
+  // input.sessionID: string
+  // output.context: string[]  — additional context for compaction prompt
+  // output.prompt?: string    — if set, replaces default compaction prompt entirely
+}
+```
+
+### chat.message
+
+Called when a new message is received.
+
+```ts
+"chat.message": async (input, output) => {
+  // input.sessionID: string
+  // input.agent?: string
+  // input.model?: { providerID, modelID }
+  // output.message: UserMessage
+  // output.parts: Part[]
+}
+```
+
+## Examples
+
+### Safety guard
+```ts
+export default {
+  "tool.execute.before": async (input, output) => {
+    if (input.tool === "bash") {
+      const cmd = output.args.command ?? ""
+      if (/rm\s+-rf\s+\//.test(cmd)) {
+        output.cancel = true
+        output.cancelReason = "Blocked: dangerous rm -rf on root"
+      }
+    }
+  },
+}
+```
+
+### Auto-approve reads
+```ts
+export default {
+  "permission.ask": async (input, output) => {
+    if (input.permission === "read" || input.permission === "glob" || input.permission === "grep") {
+      output.status = "allow"
+    }
+  },
+}
+```
+
+### Inject project context into system prompt
+```ts
+import { readFileSync } from "fs"
+
+export default {
+  "experimental.chat.system.transform": async (input, output) => {
+    try {
+      const ctx = readFileSync(".mimocode/project-context.md", "utf-8")
+      output.system.push(ctx)
+    } catch {}
+  },
+}
+```

package/src/skill/compose/.bundle/self-extend/reference/skill-api.md

@@ -0,0 +1,114 @@
+# Skill API Reference
+
+## File Structure
+
+```
+.mimocode/skills/<skill-name>/
+├── SKILL.md              # Required — main skill document
+├── supporting-file.md    # Optional — reference material
+└── scripts/              # Optional — executable scripts
+    └── helper.sh
+```
+
+## SKILL.md Format
+
+```markdown
+---
+name: my-skill-name
+description: Use when [triggering conditions]
+---
+
+# Skill Title
+
+Content loaded into conversation when the skill is invoked.
+```
+
+### Frontmatter Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | yes | Unique identifier (letters, numbers, hyphens only) |
+| `description` | yes | When to use — starts with "Use when..." (max ~500 chars) |
+| `hidden` | no | If `true`, not shown in skill list (agent can still load by name) |
+
+### Description Guidelines
+
+- Start with "Use when..." — focus on **triggering conditions**, not what the skill does
+- Don't summarize the workflow (agent may follow the summary instead of reading the full content)
+- Include symptoms, situations, contexts that signal this skill applies
+- Write in third person
+
+```yaml
+# ❌ BAD: summarizes workflow
+description: Creates tools and hooks by writing files to .mimocode directories
+
+# ✅ GOOD: triggering conditions only
+description: Use when you want to evolve your own capabilities or notice repeated patterns worth automating
+```
+
+## Skill Content
+
+The body after frontmatter is injected into the conversation when the skill is loaded. It can contain:
+
+- Instructions and workflows
+- Code examples (inline)
+- Reference to supporting files via `@filename.md` (loads the file)
+- Flowcharts (DOT format)
+- Tables, lists, any markdown
+
+## Referencing Supporting Files
+
+Use `@filename` to reference files in the same skill directory:
+
+```markdown
+See @reference/detailed-api.md for the full API specification.
+```
+
+The file content is loaded on demand when the agent accesses it.
+
+## Examples
+
+### Simple technique skill
+```markdown
+---
+name: retry-pattern
+description: Use when implementing retry logic, handling transient failures, or dealing with flaky external services
+---
+
+# Retry Pattern
+
+## Core Pattern
+\```ts
+async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
+  for (let i = 0; i < maxRetries; i++) {
+    try { return await fn() }
+    catch (e) { if (i === maxRetries - 1) throw e; await sleep(2 ** i * 100) }
+  }
+  throw new Error("unreachable")
+}
+\```
+
+## When NOT to use
+- Deterministic errors (400, 404) — retrying won't help
+- Operations with side effects that can't be repeated safely
+```
+
+### Reference skill with supporting files
+```markdown
+---
+name: project-api
+description: Use when working with this project's REST API endpoints, authentication, or data models
+---
+
+# Project API Reference
+
+See @endpoints.md for the full endpoint list.
+See @auth.md for authentication flow.
+See @models.md for data model schemas.
+```
+
+## Hot-Reload Behavior
+
+- New skills appear in the available skills list on the next turn
+- Modified skills are reloaded on the next turn
+- The agent can invoke skills via the skill tool or `/skill-name`