claude-all-hands 1.0.1 → 1.0.3

package/.claude/envoy/src/lib/prompts.ts

@@ -0,0 +1,231 @@
+/**
+ * Prompt file operations.
+ */
+
+import { existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { ensurePlanDir, getPlanPaths, getPromptPath } from "./paths.js";
+import { readMarkdownFile, writeMarkdownWithFrontMatter } from "./markdown.js";
+
+export interface PromptFrontMatter {
+  number: number;
+  variant: string | null;
+  description: string;
+  kind: "debug" | "feature";
+  relevant_files: string[];
+  success_criteria: string;
+  depends_on: number[];
+  requires_manual_testing: boolean;
+  in_progress: boolean;
+  current_iteration: number;
+  reviews: Array<{
+    review_context: string;
+    decision: "approved" | "needs_changes" | "rejected";
+    total_questions: number;
+    were_changes_suggested: boolean;
+  }>;
+  delegated_to: "frontend" | "backend" | "fullstack" | null;
+  worktree_branch_name: string | null;
+  status: "unimplemented" | "implemented" | "reviewed" | "tested" | "merged";
+  variant_solution: "discard" | "accept" | "feature-flag" | null;
+  design_files: Array<{ path: string; description: string }>;
+  walkthrough: Array<{
+    iteration: number;
+    type: "initial" | "review-refinement" | "testing-refinement";
+    refinement_reason: string | null;
+    approach: string;
+    changes: Array<{ file: string; description: string }>;
+    decisions: Array<{ decision: string; rationale: string }>;
+  }>;
+  documentation_extracted: boolean;
+  planned_at: string;
+  merge_commit_hash: string | null;
+}
+
+/**
+ * Create default prompt front matter.
+ */
+export function createDefaultPromptFrontMatter(
+  number: number,
+  variant: string | null
+): PromptFrontMatter {
+  return {
+    number,
+    variant,
+    description: "",
+    kind: "feature",
+    relevant_files: [],
+    success_criteria: "",
+    depends_on: [],
+    requires_manual_testing: false,
+    in_progress: false,
+    current_iteration: 1,
+    reviews: [],
+    delegated_to: null,
+    worktree_branch_name: null,
+    status: "unimplemented",
+    variant_solution: null,
+    design_files: [],
+    walkthrough: [],
+    documentation_extracted: false,
+    planned_at: new Date().toISOString(),
+    merge_commit_hash: null,
+  };
+}
+
+/**
+ * Read a prompt file.
+ */
+export function readPrompt(
+  number: number,
+  variant?: string | null
+): { frontMatter: PromptFrontMatter; content: string } | null {
+  const promptPath = getPromptPath(number, variant);
+  const result = readMarkdownFile(promptPath);
+  if (!result) return null;
+  return {
+    frontMatter: result.frontMatter as unknown as PromptFrontMatter,
+    content: result.content,
+  };
+}
+
+/**
+ * Write a prompt file.
+ */
+export function writePrompt(
+  number: number,
+  variant: string | null,
+  frontMatter: Partial<PromptFrontMatter>,
+  content: string
+): void {
+  const paths = getPlanPaths();
+  ensurePlanDir();
+
+  // Ensure prompts directory exists
+  if (!existsSync(paths.prompts)) {
+    mkdirSync(paths.prompts, { recursive: true });
+  }
+
+  const defaults = createDefaultPromptFrontMatter(number, variant);
+  const merged = { ...defaults, ...frontMatter };
+  const promptPath = getPromptPath(number, variant);
+  writeMarkdownWithFrontMatter(promptPath, merged, content);
+}
+
+/**
+ * Delete a prompt file.
+ */
+export function deletePrompt(number: number, variant?: string | null): boolean {
+  const promptPath = getPromptPath(number, variant);
+  if (existsSync(promptPath)) {
+    unlinkSync(promptPath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * List all prompt files in the prompts directory.
+ * Returns array of { number, variant, path }
+ */
+export function listPrompts(): Array<{
+  number: number;
+  variant: string | null;
+  path: string;
+}> {
+  const paths = getPlanPaths();
+  if (!existsSync(paths.prompts)) {
+    return [];
+  }
+
+  const files = readdirSync(paths.prompts).filter((f) => f.endsWith(".md"));
+  const prompts: Array<{ number: number; variant: string | null; path: string }> = [];
+
+  for (const file of files) {
+    // Match patterns: 1.md, 1_A.md, 12.md, 12_B.md
+    const match = file.match(/^(\d+)(?:_([A-Z]))?\.md$/);
+    if (match) {
+      prompts.push({
+        number: parseInt(match[1], 10),
+        variant: match[2] || null,
+        path: join(paths.prompts, file),
+      });
+    }
+  }
+
+  return prompts.sort((a, b) => {
+    if (a.number !== b.number) return a.number - b.number;
+    if (!a.variant && b.variant) return -1;
+    if (a.variant && !b.variant) return 1;
+    return (a.variant || "").localeCompare(b.variant || "");
+  });
+}
+
+/**
+ * Read all prompts and return their full data.
+ */
+export function readAllPrompts(): Array<{
+  number: number;
+  variant: string | null;
+  frontMatter: PromptFrontMatter;
+  content: string;
+}> {
+  const promptList = listPrompts();
+  const results: Array<{
+    number: number;
+    variant: string | null;
+    frontMatter: PromptFrontMatter;
+    content: string;
+  }> = [];
+
+  for (const prompt of promptList) {
+    const data = readPrompt(prompt.number, prompt.variant);
+    if (data) {
+      results.push({
+        number: prompt.number,
+        variant: prompt.variant,
+        ...data,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Update prompt status.
+ */
+export function updatePromptStatus(
+  number: number,
+  variant: string | null,
+  status: PromptFrontMatter["status"]
+): boolean {
+  const prompt = readPrompt(number, variant);
+  if (!prompt) return false;
+
+  const updatedFrontMatter: PromptFrontMatter = {
+    ...prompt.frontMatter,
+    status,
+  };
+  writePrompt(number, variant, updatedFrontMatter, prompt.content);
+  return true;
+}
+
+/**
+ * Update prompt variant_solution field.
+ */
+export function updatePromptVariantSolution(
+  number: number,
+  variant: string | null,
+  variantSolution: PromptFrontMatter["variant_solution"]
+): boolean {
+  const prompt = readPrompt(number, variant);
+  if (!prompt) return false;
+
+  const updatedFrontMatter: PromptFrontMatter = {
+    ...prompt.frontMatter,
+    variant_solution: variantSolution,
+  };
+  writePrompt(number, variant, updatedFrontMatter, prompt.content);
+  return true;
+}

package/.claude/envoy/src/lib/protocols.ts

@@ -0,0 +1,314 @@
+/**
+ * Protocol YAML parser with inheritance support.
+ *
+ * Protocols define sequential workflows for agents to follow.
+ * Extension protocols can:
+ * - Replace a step: declare same step number (e.g., `7:`)
+ * - Append to a step: use `+` suffix (e.g., `6+:`)
+ * - Insert new steps: use dot notation (e.g., `6.1:`, `6.2:`)
+ */
+
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import YAML from "yaml";
+import { getProjectRoot } from "./git.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ProtocolInput {
+  name: string;
+  type: "integer" | "string" | "array";
+  optional: boolean;
+  description: string;
+}
+
+export interface ProtocolOutput {
+  value: string;
+  description: string;
+}
+
+export interface Protocol {
+  name: string;
+  description: string;
+  extends: string | null;
+  inputs: ProtocolInput[] | null;
+  outputs: ProtocolOutput[];
+  steps: Record<string, string>;
+}
+
+export interface ResolvedStep {
+  number: number;
+  subNumber: number;
+  content: string;
+}
+
+export interface ResolvedProtocol {
+  name: string;
+  description: string;
+  inputs: ProtocolInput[];
+  outputs: ProtocolOutput[];
+  steps: ResolvedStep[];
+}
+
+// ============================================================================
+// Protocol Resolution
+// ============================================================================
+
+/**
+ * Get protocols directory path.
+ */
+export function getProtocolsDir(): string {
+  return join(getProjectRoot(), ".claude", "protocols");
+}
+
+/**
+ * Get protocol file path by name.
+ */
+export function getProtocolPath(name: string): string {
+  return join(getProtocolsDir(), `${name}.yaml`);
+}
+
+/**
+ * Read a protocol file.
+ */
+export function readProtocol(name: string): Protocol | null {
+  const path = getProtocolPath(name);
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(path, "utf-8");
+    return YAML.parse(content) as Protocol;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse a step key into its components.
+ *
+ * Examples:
+ * - "1" -> { base: 1, sub: 0, append: false }
+ * - "6+" -> { base: 6, sub: 0, append: true }
+ * - "6.1" -> { base: 6, sub: 1, append: false }
+ * - "13.1" -> { base: 13, sub: 1, append: false }
+ */
+function parseStepKey(key: string): { base: number; sub: number; append: boolean } {
+  // Check for append modifier
+  const append = key.endsWith("+");
+  const cleanKey = append ? key.slice(0, -1) : key;
+
+  // Check for dot notation
+  if (cleanKey.includes(".")) {
+    const [baseStr, subStr] = cleanKey.split(".");
+    return {
+      base: parseInt(baseStr, 10),
+      sub: parseInt(subStr, 10),
+      append: false, // Dot notation doesn't support append
+    };
+  }
+
+  return {
+    base: parseInt(cleanKey, 10),
+    sub: 0,
+    append,
+  };
+}
+
+/**
+ * Merge child protocol steps into base protocol steps.
+ *
+ * Inheritance rules:
+ * - Replace: Same step number replaces base step
+ * - Append: `+` suffix appends content to base step
+ * - Insert: Dot notation inserts new steps (e.g., 6.1 between 6 and 7)
+ */
+function mergeSteps(
+  baseSteps: Record<string, string>,
+  childSteps: Record<string, string>
+): Record<string, string> {
+  const merged = { ...baseSteps };
+
+  for (const [key, content] of Object.entries(childSteps)) {
+    const parsed = parseStepKey(key);
+
+    if (parsed.sub > 0) {
+      // Insert: New step with dot notation (e.g., "6.1")
+      // Store with dot notation key
+      merged[key] = content;
+    } else if (parsed.append) {
+      // Append: Add content to existing step
+      const baseKey = String(parsed.base);
+      if (merged[baseKey]) {
+        merged[baseKey] = merged[baseKey].trimEnd() + "\n" + content;
+      } else {
+        // If base step doesn't exist, just set it
+        merged[baseKey] = content;
+      }
+    } else {
+      // Replace: Same step number replaces base step
+      merged[key] = content;
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Convert steps record to sorted array of resolved steps.
+ */
+function sortSteps(steps: Record<string, string>): ResolvedStep[] {
+  const resolved: ResolvedStep[] = [];
+
+  for (const [key, content] of Object.entries(steps)) {
+    const parsed = parseStepKey(key);
+    resolved.push({
+      number: parsed.base,
+      subNumber: parsed.sub,
+      content: content.trim(),
+    });
+  }
+
+  // Sort by base number, then by sub number
+  resolved.sort((a, b) => {
+    if (a.number !== b.number) {
+      return a.number - b.number;
+    }
+    return a.subNumber - b.subNumber;
+  });
+
+  return resolved;
+}
+
+/**
+ * Resolve a protocol with inheritance.
+ * Returns null if protocol not found.
+ */
+export function resolveProtocol(name: string): ResolvedProtocol | null {
+  const protocol = readProtocol(name);
+  if (!protocol) {
+    return null;
+  }
+
+  // If no extends, return as-is
+  if (!protocol.extends) {
+    return {
+      name: protocol.name,
+      description: protocol.description,
+      inputs: protocol.inputs || [],
+      outputs: protocol.outputs || [],
+      steps: sortSteps(protocol.steps),
+    };
+  }
+
+  // Resolve base protocol recursively
+  const baseProtocol = resolveProtocol(protocol.extends);
+  if (!baseProtocol) {
+    // Base protocol not found, return current protocol without inheritance
+    return {
+      name: protocol.name,
+      description: protocol.description,
+      inputs: protocol.inputs || [],
+      outputs: protocol.outputs || [],
+      steps: sortSteps(protocol.steps),
+    };
+  }
+
+  // Merge steps
+  // First, convert base steps back to record format
+  const baseStepsRecord: Record<string, string> = {};
+  for (const step of baseProtocol.steps) {
+    const key = step.subNumber > 0
+      ? `${step.number}.${step.subNumber}`
+      : String(step.number);
+    baseStepsRecord[key] = step.content;
+  }
+
+  const mergedSteps = mergeSteps(baseStepsRecord, protocol.steps);
+
+  // Use child's inputs if specified, otherwise inherit from base
+  const inputs = protocol.inputs !== null ? protocol.inputs : baseProtocol.inputs;
+
+  // Use child's outputs if specified, otherwise inherit from base
+  const outputs = protocol.outputs.length > 0 ? protocol.outputs : baseProtocol.outputs;
+
+  return {
+    name: protocol.name,
+    description: protocol.description,
+    inputs: inputs || [],
+    outputs: outputs || [],
+    steps: sortSteps(mergedSteps),
+  };
+}
+
+/**
+ * Format a resolved protocol for output.
+ * Returns a string with:
+ * - Protocol name and description
+ * - Inputs/outputs schema
+ * - Numbered steps
+ */
+export function formatProtocol(protocol: ResolvedProtocol): string {
+  const lines: string[] = [];
+
+  // Header
+  lines.push(`# ${protocol.name}`);
+  lines.push(`${protocol.description}`);
+  lines.push("");
+
+  // Inputs
+  if (protocol.inputs.length > 0) {
+    lines.push("## Inputs");
+    for (const input of protocol.inputs) {
+      const optional = input.optional ? "(optional)" : "(required)";
+      lines.push(`- ${input.name}: ${input.type} ${optional} - ${input.description}`);
+    }
+    lines.push("");
+  }
+
+  // Outputs
+  if (protocol.outputs.length > 0) {
+    lines.push("## Outputs");
+    for (const output of protocol.outputs) {
+      lines.push(`- ${output.value}`);
+      lines.push(`  ${output.description}`);
+    }
+    lines.push("");
+  }
+
+  // Steps
+  lines.push("## Steps");
+  lines.push("");
+
+  let stepCounter = 1;
+  for (const step of protocol.steps) {
+    // Use sequential numbering for output
+    lines.push(`${stepCounter}: ${step.content}`);
+    lines.push("");
+    stepCounter++;
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * List all available protocol names.
+ */
+export function listProtocols(): string[] {
+  const dir = getProtocolsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+
+  try {
+    const files = readdirSync(dir);
+    return files
+      .filter((f) => f.endsWith(".yaml"))
+      .map((f) => f.replace(".yaml", ""));
+  } catch {
+    return [];
+  }
+}

package/.claude/envoy/src/lib/repomix.ts

@@ -0,0 +1,133 @@
+/**
+ * Repomix utilities for token counting.
+ * Extracted from commands/repomix.ts for reuse by blocking gates.
+ */
+
+import { spawnSync } from "child_process";
+
+export interface TreeEntry {
+  path: string;
+  tokens: number;
+}
+
+export interface RepomixResult {
+  success: boolean;
+  output: string;
+  tokenCount: number;
+  tree: TreeEntry[];
+  error?: string;
+}
+
+/**
+ * Parse the token count tree from repomix output.
+ * Builds full paths by tracking parent directories.
+ */
+export function parseTokenTree(output: string, maxDepth: number): TreeEntry[] {
+  const entries: TreeEntry[] = [];
+
+  const treeMatch = output.match(/Token Count Tree:[\s\S]*?(?=\n\n|\n🔎|\n📊|$)/);
+  if (!treeMatch) return entries;
+
+  const lines = treeMatch[0].split("\n").slice(2);
+  const pathStack: string[] = [];
+
+  for (const line of lines) {
+    const match = line.match(/^([│├└─\s]+)(.+?)\s+\(([0-9,]+)\s+tokens?\)/);
+    if (!match) continue;
+
+    const prefix = match[1];
+    const name = match[2].trim();
+    const tokens = parseInt(match[3].replace(/,/g, ""), 10);
+    const depth = Math.floor(prefix.length / 4);
+
+    pathStack.length = depth;
+    const fullPath = [...pathStack, name].join("");
+
+    if (name.endsWith("/")) {
+      pathStack.push(name);
+    }
+
+    if (maxDepth <= 0 || depth <= maxDepth) {
+      entries.push({ path: fullPath, tokens });
+    }
+  }
+
+  return entries.sort((a, b) => b.tokens - a.tokens);
+}
+
+/**
+ * Run repomix on paths and return token info.
+ */
+export function runRepomix(paths: string[], tokenCountOnly: boolean): RepomixResult {
+  const cmd = ["npx", "repomix@latest", ...paths];
+
+  if (tokenCountOnly) {
+    cmd.push("--token-count-tree");
+  } else {
+    cmd.push("--stdout");
+  }
+
+  const result = spawnSync(cmd[0], cmd.slice(1), {
+    encoding: "utf-8",
+    timeout: 300000,
+    maxBuffer: 50 * 1024 * 1024,
+  });
+
+  if (result.status !== 0) {
+    return {
+      success: false,
+      output: result.stderr || "repomix failed",
+      tokenCount: 0,
+      tree: [],
+      error: result.stderr || "repomix failed",
+    };
+  }
+
+  const output = result.stdout || "";
+
+  let tokenCount = 0;
+  const tokenMatch = output.match(/Total\s+Tokens?:\s+([\d,]+)/i);
+  if (tokenMatch) {
+    tokenCount = parseInt(tokenMatch[1].replace(/,/g, ""), 10);
+  }
+
+  const maxDepth = parseInt(process.env.REPOMIX_MAX_DEPTH || "0", 10);
+  const tree = parseTokenTree(output, maxDepth);
+
+  return { success: true, output, tokenCount, tree };
+}
+
+/**
+ * Get token count for a single file.
+ * Returns the file's token count (not wrapper overhead).
+ */
+export function getFileTokenCount(filePath: string): {
+  success: boolean;
+  tokenCount: number;
+  error?: string;
+} {
+  const result = runRepomix([filePath], true);
+
+  if (!result.success) {
+    return { success: false, tokenCount: 0, error: result.error };
+  }
+
+  // Find the specific file in the tree (it will be the only file entry)
+  const fileEntry = result.tree.find((e) => !e.path.endsWith("/"));
+  const tokenCount = fileEntry?.tokens ?? 0;
+
+  return { success: true, tokenCount };
+}
+
+/**
+ * Get max log tokens from env or default.
+ * Default: 10000 tokens
+ */
+export function getMaxLogTokens(): number {
+  const envVal = process.env.MAX_LOGS_TOKENS;
+  if (envVal) {
+    const parsed = parseInt(envVal, 10);
+    if (!isNaN(parsed) && parsed > 0) return parsed;
+  }
+  return 10000;
+}