claude-all-hands 1.0.2 → 1.0.3

package/.claude/envoy/src/lib/tree-sitter-utils.ts

@@ -0,0 +1,301 @@
+/**
+ * Tree-sitter utilities for AST parsing and symbol resolution.
+ * Used by docs commands for symbol lookup and validation.
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { extname } from "path";
+import {
+  getLanguageForExtension,
+  getQueriesForLanguage,
+  type LanguageQueries,
+} from "./ast-queries.js";
+
+export interface SymbolLocation {
+  name: string;
+  startLine: number;
+  endLine: number;
+  type: string;
+}
+
+export interface ParseResult {
+  success: boolean;
+  language?: string;
+  symbols?: SymbolLocation[];
+  error?: string;
+}
+
+// Tree-sitter Query types
+interface QueryCapture {
+  name: string;
+  node: {
+    text: string;
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
+  };
+}
+
+interface QueryMatch {
+  pattern: number;
+  captures: QueryCapture[];
+}
+
+interface Query {
+  matches(node: unknown): QueryMatch[];
+}
+
+interface QueryConstructor {
+  new (grammar: unknown, queryString: string): Query;
+}
+
+// Parser data type including Query constructor
+interface ParserData {
+  parser: unknown;
+  grammar: unknown;
+  QueryClass: QueryConstructor;
+}
+
+// Lazy-loaded parsers cache - stores parser, grammar, and Query class
+const parserCache = new Map<string, ParserData>();
+
+/**
+ * Get or create a tree-sitter parser for a language.
+ * Lazily loads grammars to avoid startup cost.
+ * Returns parser, grammar, and Query class (needed for Query API).
+ */
+async function getParser(language: string): Promise<ParserData | null> {
+  if (parserCache.has(language)) {
+    return parserCache.get(language)!;
+  }
+
+  try {
+    // Dynamic import tree-sitter
+    const TreeSitter = await import("tree-sitter");
+    const Parser = TreeSitter.default;
+    const QueryClass = (TreeSitter as unknown as { Query: QueryConstructor }).Query;
+
+    // Load language grammar
+    let grammar: unknown;
+    switch (language) {
+      case "typescript":
+        grammar = (await import("tree-sitter-typescript")).default.typescript;
+        break;
+      case "javascript":
+        grammar = (await import("tree-sitter-javascript")).default;
+        break;
+      case "python":
+        grammar = (await import("tree-sitter-python")).default;
+        break;
+      case "go":
+        grammar = (await import("tree-sitter-go")).default;
+        break;
+      case "rust":
+        grammar = (await import("tree-sitter-rust")).default;
+        break;
+      case "java":
+        grammar = (await import("tree-sitter-java")).default;
+        break;
+      case "ruby":
+        grammar = (await import("tree-sitter-ruby")).default;
+        break;
+      case "swift":
+        grammar = (await import("tree-sitter-swift")).default;
+        break;
+      default:
+        return null;
+    }
+
+    const parser = new Parser();
+    parser.setLanguage(grammar as Parameters<typeof parser.setLanguage>[0]);
+    const cached: ParserData = { parser, grammar, QueryClass };
+    parserCache.set(language, cached);
+    return cached;
+  } catch (e) {
+    console.error(`Failed to load parser for ${language}:`, e);
+    return null;
+  }
+}
+
+/**
+ * Parse a file and extract all symbol definitions.
+ */
+export async function parseFile(filePath: string): Promise<ParseResult> {
+  const ext = extname(filePath);
+  const language = getLanguageForExtension(ext);
+
+  if (!language) {
+    return {
+      success: false,
+      error: `Unsupported file extension: ${ext}`,
+    };
+  }
+
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+    };
+  }
+
+  const parserData = await getParser(language);
+  if (!parserData) {
+    return {
+      success: false,
+      error: `No parser available for ${language}`,
+    };
+  }
+
+  try {
+    const sourceCode = readFileSync(filePath, "utf-8");
+    const tree = (parserData.parser as { parse(source: string): unknown }).parse(sourceCode);
+    const queries = getQueriesForLanguage(language);
+
+    if (!queries) {
+      return {
+        success: false,
+        error: `No queries defined for ${language}`,
+      };
+    }
+
+    const symbols = extractSymbols(tree, queries, parserData.grammar, parserData.QueryClass);
+
+    return {
+      success: true,
+      language,
+      symbols,
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+}
+
+/**
+ * Find a specific symbol in a file.
+ */
+export async function findSymbol(
+  filePath: string,
+  symbolName: string
+): Promise<SymbolLocation | null> {
+  const result = await parseFile(filePath);
+
+  if (!result.success || !result.symbols) {
+    return null;
+  }
+
+  return result.symbols.find((s) => s.name === symbolName) || null;
+}
+
+/**
+ * Check if a symbol exists in a file.
+ */
+export async function symbolExists(
+  filePath: string,
+  symbolName: string
+): Promise<boolean> {
+  const symbol = await findSymbol(filePath, symbolName);
+  return symbol !== null;
+}
+
+// Cache compiled queries to avoid recompilation
+const queryCache = new Map<string, Query>();
+
+/**
+ * Extract symbols from a parsed tree using tree-sitter's Query API.
+ * This uses the declarative query patterns from ast-queries.ts.
+ */
+function extractSymbols(
+  tree: unknown,
+  queries: LanguageQueries,
+  grammar: unknown,
+  QueryClass: QueryConstructor
+): SymbolLocation[] {
+  const symbols: SymbolLocation[] = [];
+  const root = (tree as { rootNode: unknown }).rootNode;
+
+  for (const [symbolType, queryDef] of Object.entries(queries)) {
+    const cacheKey = `${symbolType}:${queryDef.query}`;
+
+    let query = queryCache.get(cacheKey);
+    if (!query) {
+      try {
+        query = new QueryClass(grammar, queryDef.query);
+        queryCache.set(cacheKey, query);
+      } catch (e) {
+        // Query compilation failed - skip this symbol type
+        console.error(`Failed to compile query for ${symbolType}:`, e);
+        continue;
+      }
+    }
+
+    try {
+      const matches = query.matches(root);
+      for (const match of matches) {
+        const nameCapture = match.captures.find(c => c.name === queryDef.nameCapture);
+        if (nameCapture) {
+          symbols.push({
+            name: nameCapture.node.text,
+            startLine: nameCapture.node.startPosition.row + 1,
+            endLine: nameCapture.node.endPosition.row + 1,
+            type: symbolType,
+          });
+        }
+      }
+    } catch (e) {
+      // Query execution failed - skip this symbol type
+      console.error(`Failed to execute query for ${symbolType}:`, e);
+      continue;
+    }
+  }
+
+  return symbols;
+}
+
+/**
+ * Get complexity metrics for a file.
+ */
+export async function getFileComplexity(filePath: string): Promise<{
+  lines: number;
+  imports: number;
+  exports: number;
+  functions: number;
+  classes: number;
+} | null> {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").length;
+
+    const result = await parseFile(filePath);
+    if (!result.success || !result.symbols) {
+      // Fallback to regex-based counting for unsupported files
+      return {
+        lines,
+        imports: (content.match(/^import\s/gm) || []).length,
+        exports: (content.match(/^export\s/gm) || []).length,
+        functions: (content.match(/function\s+\w+/g) || []).length,
+        classes: (content.match(/class\s+\w+/g) || []).length,
+      };
+    }
+
+    const functions = result.symbols.filter(
+      (s) => s.type === "function" || s.type === "method" || s.type === "arrowFunction"
+    ).length;
+    const classes = result.symbols.filter(
+      (s) => s.type === "class" || s.type === "struct" || s.type === "interface"
+    ).length;
+
+    // Count imports/exports via regex (simpler than AST for this)
+    const imports = (content.match(/^import\s/gm) || []).length;
+    const exports = (content.match(/^export\s/gm) || []).length;
+
+    return { lines, imports, exports, functions, classes };
+  } catch {
+    return null;
+  }
+}

package/.claude/envoy/src/types/tree-sitter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Type declarations for tree-sitter and language grammars.
+ * These packages don't have bundled types, so we declare them here.
+ */
+
+declare module "tree-sitter" {
+  export interface SyntaxNode {
+    type: string;
+    text: string;
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
+    children: SyntaxNode[];
+    namedChildren: SyntaxNode[];
+    childForFieldName(fieldName: string): SyntaxNode | null;
+    parent: SyntaxNode | null;
+  }
+
+  export interface Tree {
+    rootNode: SyntaxNode;
+  }
+
+  export interface Language {}
+
+  export default class Parser {
+    setLanguage(language: Language): void;
+    parse(input: string): Tree;
+  }
+}
+
+declare module "tree-sitter-typescript" {
+  import { Language } from "tree-sitter";
+  const grammar: { typescript: Language; tsx: Language };
+  export default grammar;
+}
+
+declare module "tree-sitter-javascript" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-python" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-go" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-rust" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-java" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-ruby" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}
+
+declare module "tree-sitter-swift" {
+  import { Language } from "tree-sitter";
+  const grammar: Language;
+  export default grammar;
+}

package/.claude/hooks/scripts/enforce_research_fetch.py

@@ -12,6 +12,6 @@ if not url:
 # JSON output with additionalContext for Claude self-correction
 print(json.dumps({
     "continue": False,
-    "additionalContext": "WebFetch blocked.\n\nMain agent: delegate to researcher agent.\nSubagent: use `.claude/envoy/envoy tavily extract \"<url>\"` instead."
+    "additionalContext": "WebFetch blocked.\n\nMain agent: delegate to researcher agent.\nSubagent: use `envoy tavily extract \"<url>\"` instead."
 }))
 sys.exit(0)

package/.claude/protocols/bug-discovery.yaml

@@ -19,7 +19,7 @@ outputs:
     description: bug hypotheses written to file via envoy commands
 steps:
   1: |
-    **Query documentation first**: Call `envoy knowledge search docs "<suspected area + symptoms as descriptive phrase>"` (semantic search - full phrases, not keywords)
+    **Query documentation first**: Call `envoy knowledge search "<suspected area + symptoms as descriptive phrase>"` (semantic search - full phrases, not keywords)
     * Check for documented anti-patterns that might explain the bug
     * Note any constraints that must be preserved in the fix
   2: |

package/.claude/protocols/discovery.yaml

@@ -19,7 +19,7 @@ outputs:
     description: findings written to file via envoy commands
 steps:
   1: |
-    **Query documentation first**: Call `envoy knowledge search docs "<focused requirement area as descriptive request>"` (semantic search - full phrases, not keywords)
+    **Query documentation first**: Call `envoy knowledge search "<focused requirement area as descriptive request>"` (semantic search - full phrases, not keywords)
     * May run multiple searches if requirements span distinct focus areas
     * Use returned docs as context for approach building - reference existing patterns rather than reinventing
     * Note any constraints or anti-patterns documented for this area

package/.claude/settings.json

@@ -3,8 +3,8 @@
   "env": {
     "PARALLEL_MAX_WORKERS": "3",
     "PROJECT_NAME": "test-target",
-    "SEARCH_SIMILARITY_THRESHOLD": "0.64",
-    "SEARCH_FULL_CONTEXT_SIMILARITY_THRESHOLD": "0.72",
+    "SEARCH_SIMILARITY_THRESHOLD": "0.65",
+    "SEARCH_FULL_CONTEXT_SIMILARITY_THRESHOLD": "0.82",
     "SEARCH_CONTEXT_TOKEN_LIMIT": "5000",
     "MAX_LOGS_TOKENS": "10000",
     "BASH_MAX_TIMEOUT_MS": "3600000",
@@ -21,9 +21,10 @@
       "Bash(ls:*)",
       "Bash(rg:*)",
       "Bash(mkdir:*)",
+      "Bash(mkdir -p:*)",
       "Bash(npx repomix@latest:*)",
       "Read(~/.claude-code-docs/docs/*)",
-      "Bash(.claude/envoy/envoy:*)",
+      "Bash(envoy:*)",
       "SlashCommand(/plan:*)"
     ],
     "deny": [],

package/.claude/skills/discovery-mode/SKILL.md

@@ -10,14 +10,14 @@ Enable agents to perform read-only codebase analysis during planning phase. Agen
 <quick_start>
 ```bash
 # Write approach (required)
-.claude/envoy/envoy plans write-approach \
+envoy plans write-approach \
   --specialist "<your-name>" \
   --summary "2-3 sentence summary" \
   --files '[{"path": "src/auth/service.ts", "purpose": "Core auth logic"}]' \
   --content "Full analysis..."
 
 # Write options (when alternatives exist)
-.claude/envoy/envoy plans write-option \
+envoy plans write-option \
   --specialist "<your-name>" \
   --id "1A" --group "Token storage" --name "httpOnly cookies" \
   --summary "Store tokens in httpOnly cookies..." \
@@ -44,7 +44,7 @@ Use: Glob, Grep, Read
 
 **Approach (required)**:
 ```bash
-.claude/envoy/envoy plans write-approach \
+envoy plans write-approach \
   --specialist "<name>" \
   --summary "Brief summary for main agent" \
   --files '[{"path": "...", "purpose": "..."}]' \
@@ -54,7 +54,7 @@ Use: Glob, Grep, Read
 
 **Options (only if alternatives exist that the approach file mentions)**:
 ```bash
-.claude/envoy/envoy plans write-option \
+envoy plans write-option \
   --specialist "<name>" \
   --id "1A" \
   --group "Token storage" \
@@ -83,13 +83,13 @@ When re-invoked after user feedback (re-discovery loop):
 
 ```bash
 # Check for existing findings
-.claude/envoy/envoy plans has-findings --specialist "<name>"
+envoy plans has-findings --specialist "<name>"
 
 # Read previous approach
-.claude/envoy/envoy plans read-finding --specialist "<name>" --type approach
+envoy plans read-finding --specialist "<name>" --type approach
 
 # Write new approach with --replace (clears existing options)
-.claude/envoy/envoy plans write-approach \
+envoy plans write-approach \
   --specialist "<name>" \
   --replace \
   --summary "..." \