eai-cli 0.0.0-bootstrap.0

package/resources/gofer/hook-scripts/user-prompt-submit.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+/**
+ * user-prompt-submit.mjs — Claude Code UserPromptSubmit hook
+ *
+ * Fires before every prompt is processed. Reads .specify/memory/local.json,
+ * scores memories by keyword relevance to the prompt, and outputs
+ * additionalContext via stdout for injection as a <system-reminder>.
+ *
+ * Also updates the bridge file with activity data.
+ *
+ * stdin:  JSON with { prompt, session_id, transcript_path }
+ * stdout: JSON with { hookSpecificOutput: { hookEventName, additionalContext } }
+ * Bridge: .specify/hooks/context-bridge.json
+ */
+
+import { readFileSync, writeFileSync, renameSync, mkdirSync, appendFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const MEMORY_PATH = join(PROJECT_DIR, '.specify', 'memory', 'local.json');
+const BRIDGE_PATH = join(PROJECT_DIR, '.specify', 'hooks', 'context-bridge.json');
+const DEBUG_LOG = join(PROJECT_DIR, '.specify', 'hooks', 'hook-debug.log');
+const PERF_LOG = join(PROJECT_DIR, '.specify', 'hooks', 'hook-perf.jsonl');
+const PERF_ENABLED = process.env.GOFER_PERF_LOG === '1' || process.env.GOFER_PERF_MODE === '1';
+const MAX_MEMORIES = 5;
+const MAX_CONTEXT_CHARS = 3000; // ~750 tokens
+
+function debug(msg) {
+  try {
+    const ts = new Date().toISOString();
+    appendFileSync(DEBUG_LOG, `[${ts}] [user-prompt-submit] ${msg}\n`);
+  } catch { /* ignore */ }
+}
+
+function perf(operation, start, extra = {}) {
+  if (!PERF_ENABLED) return;
+
+  try {
+    mkdirSync(dirname(PERF_LOG), { recursive: true });
+    appendFileSync(
+      PERF_LOG,
+      `${JSON.stringify({
+        hook: 'user-prompt-submit',
+        operation,
+        durationMs: Math.round((Date.now() - start) * 100) / 100,
+        timestamp: new Date().toISOString(),
+        ...extra,
+      })}\n`
+    );
+  } catch {
+    // Performance logging must never affect prompt handling.
+  }
+}
+
+function readStdin() {
+  try {
+    const raw = readFileSync(0, 'utf-8').trim();
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+function loadMemories() {
+  try {
+    const raw = readFileSync(MEMORY_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    // Support both array format and { memories: [...] } format
+    if (Array.isArray(data)) return data;
+    if (data.memories && Array.isArray(data.memories)) return data.memories;
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+function scoreMemory(memory, promptWords) {
+  const text = (memory.content || memory.text || memory.summary || '').toLowerCase();
+  const tags = (memory.tags || []).map(t => t.toLowerCase());
+  let score = 0;
+
+  for (const word of promptWords) {
+    if (text.includes(word)) score += 1;
+    if (tags.some(t => t.includes(word))) score += 2;
+  }
+
+  // Boost by priority if available
+  const priority = memory.priority || 0;
+  score += priority * 0.5;
+
+  return score;
+}
+
+function selectRelevantMemories(memories, prompt) {
+  if (!memories.length || !prompt) return memories.slice(0, MAX_MEMORIES);
+
+  // Tokenize prompt into meaningful words (3+ chars)
+  const promptWords = prompt
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length >= 3);
+
+  if (!promptWords.length) return memories.slice(0, MAX_MEMORIES);
+
+  const scored = memories
+    .map(m => ({ memory: m, score: scoreMemory(m, promptWords) }))
+    .sort((a, b) => b.score - a.score);
+
+  return scored.slice(0, MAX_MEMORIES).map(s => s.memory);
+}
+
+function formatMemoriesForContext(memories) {
+  if (!memories.length) return '';
+
+  const lines = ['Gofer Memory Context:'];
+  let totalChars = lines[0].length;
+
+  for (const m of memories) {
+    const text = m.content || m.text || m.summary || '';
+    if (!text) continue;
+
+    const line = `- ${text}`;
+    if (totalChars + line.length > MAX_CONTEXT_CHARS) break;
+    lines.push(line);
+    totalChars += line.length;
+  }
+
+  return lines.length > 1 ? lines.join('\n') : '';
+}
+
+function stripRuntimeBridgeFields(value) {
+  const copy = JSON.parse(JSON.stringify(value ?? {}));
+  delete copy.timestamp;
+  if (copy.session) {
+    delete copy.session.lastActivity;
+  }
+  if (copy.lastPrompt) {
+    delete copy.lastPrompt.timestamp;
+  }
+  return copy;
+}
+
+function bridgeEquivalent(left, right) {
+  return JSON.stringify(stripRuntimeBridgeFields(left)) === JSON.stringify(stripRuntimeBridgeFields(right));
+}
+
+function atomicWriteIfChanged(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  try {
+    const existing = JSON.parse(readFileSync(filePath, 'utf-8'));
+    if (bridgeEquivalent(existing, data)) {
+      return false;
+    }
+  } catch {
+    // Missing or invalid existing data should be replaced.
+  }
+
+  const tmpPath = filePath + '.tmp';
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+  renameSync(tmpPath, filePath);
+  return true;
+}
+
+function updateBridge(sessionId, prompt) {
+  try {
+    const start = Date.now();
+    let existing = {};
+    try {
+      existing = JSON.parse(readFileSync(BRIDGE_PATH, 'utf-8'));
+    } catch {
+      // No existing bridge
+    }
+
+    const now = Date.now();
+    const bridge = {
+      ...existing,
+      timestamp: now,
+      sessionId: sessionId || existing.sessionId || '',
+      session: {
+        active: true,
+        lastActivity: now,
+      },
+      // Capture prompt topic so agent-stop.mjs can use it for learning context
+      lastPrompt: {
+        topic: (prompt || '').substring(0, 200),
+        timestamp: now,
+      },
+    };
+
+    const written = atomicWriteIfChanged(BRIDGE_PATH, bridge);
+    debug(`Bridge ${written ? 'updated' : 'unchanged'}: session=${bridge.sessionId}`);
+    perf('bridge-write', start, { written });
+  } catch (err) {
+    debug(`Bridge write error: ${err.message}`);
+  }
+}
+
+// Main
+debug(`Hook fired. PROJECT_DIR=${PROJECT_DIR}`);
+
+const input = readStdin();
+debug(`stdin: session_id=${input.session_id}, prompt_length=${(input.prompt || '').length}`);
+
+const prompt = input.prompt || '';
+const sessionId = input.session_id || '';
+const hookStart = Date.now();
+
+// Update bridge with activity and prompt topic
+updateBridge(sessionId, prompt);
+
+// Load and score memories
+const memories = loadMemories();
+const relevant = selectRelevantMemories(memories, prompt);
+const additionalContext = formatMemoriesForContext(relevant);
+debug(`memories: loaded=${memories.length}, relevant=${relevant.length}, hasContext=${!!additionalContext}`);
+perf('memory-select', hookStart, { loaded: memories.length, relevant: relevant.length });
+
+// Output for Claude Code to inject
+if (additionalContext) {
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext,
+    },
+  };
+  process.stdout.write(JSON.stringify(output));
+}
+perf('hook-total', hookStart, { sessionId: sessionId || undefined, hasContext: !!additionalContext });

package/resources/gofer/instruction-templates/base/agents-base.md

@@ -0,0 +1,37 @@
+# AGENTS.md
+
+**Project**: {{projectName}} | **Language**: {{language}}{{frameworkLine}} |
+**Package Manager**: {{packageManager}}
+
+## Commands
+
+{{commands}}
+
+## Code Style
+
+{{codeStyle}}
+
+## Testing
+
+{{testing}}
+
+## Git Workflow
+
+{{gitWorkflow}}
+
+## Gofer Pipeline
+
+This project uses Gofer for spec-driven development. Run `/0_gofer_start` to
+start the core pipeline (business scenario -> research -> specify -> plan ->
+tasks -> implement -> validate). `/6_gofer_validate` is the terminal quality
+gate and includes the final engineering review loop. Artifacts in
+`.specify/specs/{feature}/`.
+
+## Core Principles
+
+- **Simplicity First**: Make every change as simple as possible. Impact minimal
+  code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer
+  standards.
+- **Minimal Impact**: Changes should only touch what's necessary. Avoid
+  introducing bugs.

package/resources/gofer/instruction-templates/base/claude-base.md

@@ -0,0 +1,7 @@
+# CLAUDE.md
+
+See @AGENTS.md for project conventions, commands, and code style. {{workflow}}
+
+## Gofer Pipeline
+
+{{goferCommands}}

package/resources/gofer/instruction-templates/base/copilot-base.md

@@ -0,0 +1,26 @@
+# Copilot Instructions
+
+## Project Overview
+
+{{projectOverview}}
+
+## Gofer Pipeline
+
+{{availableCommands}}
+
+## Code Quality
+
+{{codeQuality}}
+
+## Task Management
+
+1. **Plan First**: Write plan with checkable items before starting
+2. **Track Progress**: Mark items complete as you go
+3. **Verify**: Run tests and demonstrate correctness before marking done
+4. **Capture Lessons**: Update lessons file after corrections
+
+## Core Principles
+
+- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
+- **Minimal Impact**: Changes should only touch what's necessary. Avoid introducing bugs.

package/resources/gofer/instruction-templates/gofer/gofer-claude.md

@@ -0,0 +1,5 @@
+Run `/0_gofer_start` to start the core pipeline: business scenario -> research
+-> specify -> plan -> tasks -> implement -> validate. `/6_gofer_validate` is the
+terminal quality gate and includes the final engineering review loop. Use
+`/7_gofer_save` for checkpoints and `/8_gofer_branding` for branded
+document/deck templates. Artifacts go to `.specify/specs/{feature}/`.

package/resources/gofer/instruction-templates/gofer/gofer-copilot.md

@@ -0,0 +1,9 @@
+This project uses Gofer for spec-driven development. Run `/0_gofer_start` to
+start the core pipeline: business scenario -> research -> specify -> plan ->
+tasks -> implement -> validate.
+
+Key commands: `/1_gofer_research`, `/2_gofer_specify`, `/3_gofer_plan`,
+`/4_gofer_tasks`, `/5_gofer_implement`, `/6_gofer_validate`. `/6_gofer_validate`
+is the terminal quality gate and includes the final engineering review loop. Use
+`/7_gofer_save` for checkpoints and `/8_gofer_branding` for branded
+document/deck templates. Artifacts in `.specify/specs/{feature}/`.

package/resources/gofer/instruction-templates/languages/generic.md

@@ -0,0 +1,7 @@
+### Code Conventions
+
+- Follow existing code style and naming conventions in this project
+- Write clear, self-documenting code with descriptive names
+- Keep functions focused and small
+- Add comments only where the logic is not self-evident
+- Handle errors at appropriate boundaries

package/resources/gofer/instruction-templates/languages/go.md

@@ -0,0 +1,8 @@
+### Go Conventions
+
+- Always handle errors explicitly; never ignore returned errors
+- Use `gofmt` / `goimports` for formatting
+- Follow Go naming: exported = `PascalCase`, unexported = `camelCase`
+- Keep packages small and focused; avoid circular imports
+- Use `context.Context` as the first parameter for functions that do I/O
+- Prefer table-driven tests

package/resources/gofer/instruction-templates/languages/java.md

@@ -0,0 +1,8 @@
+### Java Conventions
+
+- Follow standard Maven/Gradle project layout (`src/main/java`, `src/test/java`)
+- Use `PascalCase` for classes, `camelCase` for methods and variables
+- Prefer composition over inheritance
+- Use `Optional<T>` instead of returning `null`
+- Write JUnit 5 tests; use `@ParameterizedTest` for data-driven tests
+- Add JavaDoc to all public classes and methods

package/resources/gofer/instruction-templates/languages/python.md

@@ -0,0 +1,9 @@
+### Python Conventions
+
+- Use type hints on all function signatures
+- Write docstrings for public functions and classes (Google style)
+- Use virtual environments for dependency isolation
+- Follow PEP 8 naming: `snake_case` for functions/variables, `PascalCase` for
+  classes
+- Prefer `pathlib.Path` over `os.path` for file operations
+- Use `dataclasses` or `pydantic` for structured data

package/resources/gofer/instruction-templates/languages/rust.md

@@ -0,0 +1,9 @@
+### Rust Conventions
+
+- Follow ownership rules; prefer borrowing over cloning
+- Use `Result<T, E>` for recoverable errors, `panic!` only for unrecoverable
+  bugs
+- Run `cargo fmt` before committing and `cargo clippy` for lint checks
+- Derive common traits (`Debug`, `Clone`, `PartialEq`) where appropriate
+- Use `?` operator for error propagation
+- Organize code into modules with clear public APIs

package/resources/gofer/instruction-templates/languages/typescript.md

@@ -0,0 +1,19 @@
+### TypeScript Conventions
+
+- Use strict mode (`"strict": true` in tsconfig.json)
+- Use ESM imports (`import`/`export`), never `require()`
+- Add explicit return types to all public functions
+- Prefer `unknown` over `any`; use proper type narrowing
+- Use `readonly` for properties that should not be reassigned
+- Prefer interfaces over type aliases for object shapes
+
+### Next.js App Router Guardrail
+
+- In `src/app/**/route.ts`, export only HTTP methods such as `GET`, `POST`,
+  `PUT`, `PATCH`, `DELETE`, `HEAD`, and `OPTIONS`
+- Only export supported route config fields such as `dynamic`, `runtime`, and
+  `revalidate`
+- Do not export helper functions, dependency interfaces, or test seams from
+  `route.ts`
+- Put reusable logic in a sibling `handler.ts` or a module under `src/lib/`,
+  then keep `route.ts` as a thin wrapper

package/resources/gofer/instruction-templates/workflow/principles.md

@@ -0,0 +1,52 @@
+## Workflow Orchestration
+
+### 1. Plan Node Default
+- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
+- If something goes sideways, STOP and re-plan immediately – don't keep pushing
+- Use plan mode for verification steps, not just building
+- Write detailed specs upfront to reduce ambiguity
+
+### 2. Subagent Strategy
+- Use subagents liberally to keep main context window clean
+- Offload research, exploration, and parallel analysis to subagents
+- For complex problems, throw more compute at it via subagents
+- One task per subagent for focused execution
+
+### 3. Self-Improvement Loop
+- After ANY correction from the user: update `tasks/lessons.md` with the pattern
+- Write rules for yourself that prevent the same mistake
+- Ruthlessly iterate on these lessons until mistake rate drops
+- Review lessons at session start for relevant project
+
+### 4. Verification Before Done
+- Never mark a task complete without proving it works
+- Diff behavior between main and your changes when relevant
+- Ask yourself: "Would a staff engineer approve this?"
+- Run tests, check logs, demonstrate correctness
+
+### 5. Demand Elegance (Balanced)
+- For non-trivial changes: pause and ask "is there a more elegant way?"
+- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- Skip this for simple, obvious fixes – don't over-engineer
+- Challenge your own work before presenting it
+
+### 6. Autonomous Bug Fixing
+- When given a bug report: just fix it. Don't ask for hand-holding
+- Point at logs, errors, failing tests – then resolve them
+- Zero context switching required from the user
+- Go fix failing CI tests without being told how
+
+## Task Management
+
+1. **Plan First**: Write plan to `tasks/todo.md` with checkable items
+2. **Verify Plan**: Check in before starting implementation
+3. **Track Progress**: Mark items complete as you go
+4. **Explain Changes**: High-level summary at each step
+5. **Document Results**: Add review section to `tasks/todo.md`
+6. **Capture Lessons**: Update `tasks/lessons.md` after corrections
+
+## Core Principles
+
+- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
+- **Minimal Impact**: Changes should only touch what's necessary. Avoid introducing bugs.