claude-all-hands 1.0.2 → 1.0.4

package/.claude/envoy/src/commands/knowledge.ts

@@ -1,10 +1,10 @@
 /**
- * Knowledge commands - semantic search and indexing for documentation.
+ * Knowledge commands - semantic search and indexing for docs/ documentation.
  *
  * Commands:
- *   envoy knowledge search <index_name> <query>
- *   envoy knowledge reindex-all [--index_name <name>]
- *   envoy knowledge reindex-from-changes <index_name> --files <json_array>
+ *   envoy knowledge search <query> [--metadata-only]
+ *   envoy knowledge reindex-all
+ *   envoy knowledge reindex-from-changes --files <json_array>
  */
 
 import { Command } from "commander";
@@ -16,34 +16,34 @@ const getProjectRoot = (): string => {
 };
 
 /**
- * Search command - semantic search against indexed documents
+ * Search command - semantic search against docs index
  */
 class SearchCommand extends BaseCommand {
   readonly name = "search";
-  readonly description = "Semantic search (use descriptive phrases, not keywords)";
+  readonly description = "Semantic search docs (use descriptive phrases, not keywords)";
 
   defineArguments(cmd: Command): void {
     cmd
-      .argument("<index_name>", "Index to search (docs, curator)")
-      .argument("<query>", "Descriptive phrase (e.g. 'how to handle API authentication' not 'auth')");
+      .argument("<query>", "Descriptive phrase (e.g. 'how to handle API authentication' not 'auth')")
+      .option("--metadata-only", "Return only file paths and descriptions (no full content)");
   }
 
   async execute(args: Record<string, unknown>): Promise<CommandResult> {
-    const indexName = args.index_name as string;
     const query = args.query as string;
+    const metadataOnly = !!args.metadataOnly;
 
-    if (!indexName || !query) {
-      return this.error("validation_error", "index_name and query are required");
+    if (!query) {
+      return this.error("validation_error", "query is required");
     }
 
     try {
       const service = new KnowledgeService(getProjectRoot());
-      const results = await service.search(indexName, query);
+      const results = await service.search(query, 50, metadataOnly);
 
       return this.success({
         message: "Search completed",
         query,
-        index: indexName,
+        metadata_only: metadataOnly,
         results,
         result_count: results.length,
       });
@@ -57,26 +57,24 @@ class SearchCommand extends BaseCommand {
 }
 
 /**
- * Reindex-all command - full rebuild of one or all indexes
+ * Reindex-all command - full rebuild of docs index
  */
 class ReindexAllCommand extends BaseCommand {
   readonly name = "reindex-all";
-  readonly description = "Rebuild search index from all documents";
+  readonly description = "Rebuild docs search index";
 
-  defineArguments(cmd: Command): void {
-    cmd.option("--index_name <name>", "Specific index to reindex (default: all)");
+  defineArguments(): void {
+    // No arguments
   }
 
-  async execute(args: Record<string, unknown>): Promise<CommandResult> {
-    const indexName = args.index_name as string | undefined;
-
+  async execute(): Promise<CommandResult> {
     try {
       const service = new KnowledgeService(getProjectRoot());
-      const results = await service.reindexAll(indexName);
+      const result = await service.reindexAll();
 
       return this.success({
-        message: indexName ? `Index '${indexName}' reindexed` : "All indexes reindexed",
-        stats: results,
+        message: "Docs index reindexed",
+        stats: result,
       });
     } catch (e) {
       return this.error(
@@ -92,23 +90,17 @@ class ReindexAllCommand extends BaseCommand {
  */
 class ReindexFromChangesCommand extends BaseCommand {
   readonly name = "reindex-from-changes";
-  readonly description = "Update index from changed files (for git hooks)";
+  readonly description = "Update docs index from changed files (for git hooks)";
 
   defineArguments(cmd: Command): void {
-    cmd
-      .argument("<index_name>", "Index to update (docs, curator)")
-      .requiredOption("--files <json>", "JSON array of file changes");
+    cmd.requiredOption("--files <json>", "JSON array of file changes");
   }
 
   async execute(args: Record<string, unknown>): Promise<CommandResult> {
-    const indexName = args.index_name as string;
     const filesJson = args.files as string;
 
-    if (!indexName || !filesJson) {
-      return this.error(
-        "validation_error",
-        "index_name and --files are required"
-      );
+    if (!filesJson) {
+      return this.error("validation_error", "--files is required");
     }
 
     let changes: FileChange[];
@@ -120,7 +112,7 @@ class ReindexFromChangesCommand extends BaseCommand {
 
     try {
       const service = new KnowledgeService(getProjectRoot());
-      const result = await service.reindexFromChanges(indexName, changes);
+      const result = await service.reindexFromChanges(changes);
 
       if (!result.success) {
         return {
@@ -150,25 +142,24 @@ class ReindexFromChangesCommand extends BaseCommand {
 }
 
 /**
- * Status command - check index health
+ * Status command - check docs index health
  */
 class StatusCommand extends BaseCommand {
   readonly name = "status";
-  readonly description = "Check index status and health";
+  readonly description = "Check docs index status";
 
-  defineArguments(cmd: Command): void {
-    // No arguments needed
+  defineArguments(): void {
+    // No arguments
   }
 
   async execute(): Promise<CommandResult> {
     try {
       const service = new KnowledgeService(getProjectRoot());
-      const status = await service.checkIndexes();
+      const status = await service.checkIndex();
 
       return this.success({
-        valid_indexes: status.valid,
-        missing_indexes: status.missing,
-        needs_reindex: status.missing.length > 0,
+        index_exists: status.exists,
+        needs_reindex: !status.exists,
       });
     } catch (e) {
       return this.error(

package/.claude/envoy/src/lib/ast-queries.ts

@@ -0,0 +1,261 @@
+/**
+ * Tree-sitter query patterns for symbol resolution across languages.
+ * Used by docs commands to find symbols for reference formatting.
+ */
+
+export type SymbolType = "function" | "class" | "variable" | "type" | "export" | "method" | "struct";
+
+export interface SymbolQuery {
+  query: string;
+  nameCapture: string;
+}
+
+export interface LanguageQueries {
+  [key: string]: SymbolQuery;
+}
+
+/**
+ * Language-specific tree-sitter queries for finding symbol definitions.
+ * Each query captures the symbol name via @name capture group.
+ */
+export const languageQueries: Record<string, LanguageQueries> = {
+  typescript: {
+    function: {
+      query: `(function_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    class: {
+      query: `(class_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    variable: {
+      query: `(variable_declarator name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    type: {
+      query: `(type_alias_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    interface: {
+      query: `(interface_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    method: {
+      query: `(method_definition name: (property_identifier) @name)`,
+      nameCapture: "name",
+    },
+    export: {
+      query: `(export_statement declaration: (function_declaration name: (identifier) @name))`,
+      nameCapture: "name",
+    },
+    arrowFunction: {
+      query: `(lexical_declaration
+        (variable_declarator
+          name: (identifier) @name
+          value: (arrow_function)))`,
+      nameCapture: "name",
+    },
+  },
+
+  javascript: {
+    function: {
+      query: `(function_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    class: {
+      query: `(class_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    variable: {
+      query: `(variable_declarator name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    method: {
+      query: `(method_definition name: (property_identifier) @name)`,
+      nameCapture: "name",
+    },
+    arrowFunction: {
+      query: `(lexical_declaration
+        (variable_declarator
+          name: (identifier) @name
+          value: (arrow_function)))`,
+      nameCapture: "name",
+    },
+  },
+
+  python: {
+    function: {
+      query: `(function_definition name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    class: {
+      query: `(class_definition name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    variable: {
+      query: `(assignment left: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    method: {
+      query: `(function_definition name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+  },
+
+  go: {
+    function: {
+      query: `(function_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    type: {
+      query: `(type_declaration (type_spec name: (type_identifier) @name))`,
+      nameCapture: "name",
+    },
+    method: {
+      query: `(method_declaration name: (field_identifier) @name)`,
+      nameCapture: "name",
+    },
+    variable: {
+      query: `(var_declaration (var_spec name: (identifier) @name))`,
+      nameCapture: "name",
+    },
+    const: {
+      query: `(const_declaration (const_spec name: (identifier) @name))`,
+      nameCapture: "name",
+    },
+  },
+
+  rust: {
+    function: {
+      query: `(function_item name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    struct: {
+      query: `(struct_item name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    enum: {
+      query: `(enum_item name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    impl: {
+      query: `(impl_item type: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    trait: {
+      query: `(trait_item name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    const: {
+      query: `(const_item name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+  },
+
+  java: {
+    class: {
+      query: `(class_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    interface: {
+      query: `(interface_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    method: {
+      query: `(method_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    field: {
+      query: `(field_declaration declarator: (variable_declarator name: (identifier) @name))`,
+      nameCapture: "name",
+    },
+    enum: {
+      query: `(enum_declaration name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+  },
+
+  ruby: {
+    function: {
+      query: `(method name: (identifier) @name)`,
+      nameCapture: "name",
+    },
+    class: {
+      query: `(class name: (constant) @name)`,
+      nameCapture: "name",
+    },
+    module: {
+      query: `(module name: (constant) @name)`,
+      nameCapture: "name",
+    },
+  },
+
+  swift: {
+    function: {
+      query: `(function_declaration name: (simple_identifier) @name)`,
+      nameCapture: "name",
+    },
+    class: {
+      query: `(class_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    struct: {
+      query: `(struct_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    enum: {
+      query: `(enum_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+    protocol: {
+      query: `(protocol_declaration name: (type_identifier) @name)`,
+      nameCapture: "name",
+    },
+  },
+};
+
+/**
+ * Extension to language mapping
+ */
+export const extensionToLanguage: Record<string, string> = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".rb": "ruby",
+  ".swift": "swift",
+};
+
+/**
+ * Get the language for a file extension
+ */
+export function getLanguageForExtension(ext: string): string | null {
+  return extensionToLanguage[ext] || null;
+}
+
+/**
+ * Get queries for a language
+ */
+export function getQueriesForLanguage(language: string): LanguageQueries | null {
+  return languageQueries[language] || null;
+}
+
+/**
+ * Check if a language is supported
+ */
+export function isLanguageSupported(language: string): boolean {
+  return language in languageQueries;
+}
+
+/**
+ * Get all supported extensions
+ */
+export function getSupportedExtensions(): string[] {
+  return Object.keys(extensionToLanguage);
+}