agentmap 0.7.1 → 0.9.0

package/src/languages/index.ts

@@ -0,0 +1,231 @@
+// Language registry for agentmap.
+// Aggregates all language-specific implementations.
+
+import type { Language, SyntaxNode, DefinitionType } from '../types.js'
+
+import * as typescript from './typescript.js'
+import * as javascript from './javascript.js'
+import * as python from './python.js'
+import * as rust from './rust.js'
+import * as go from './go.js'
+import * as zig from './zig.js'
+import * as cpp from './cpp.js'
+
+// Re-export language modules for direct access
+export { typescript, javascript, python, rust, go, zig, cpp }
+
+/**
+ * All registered languages
+ */
+export const languages = {
+  typescript,
+  javascript,
+  python,
+  rust,
+  go,
+  zig,
+  cpp,
+} as const
+
+/**
+ * File extension to language mapping
+ */
+export const LANGUAGE_EXTENSIONS: Record<string, Language> = {
+  ...Object.fromEntries(typescript.extensions.map(e => [e, 'typescript' as const])),
+  ...Object.fromEntries(javascript.extensions.map(e => [e, 'javascript' as const])),
+  ...Object.fromEntries(python.extensions.map(e => [e, 'python' as const])),
+  ...Object.fromEntries(rust.extensions.map(e => [e, 'rust' as const])),
+  ...Object.fromEntries(go.extensions.map(e => [e, 'go' as const])),
+  ...Object.fromEntries(zig.extensions.map(e => [e, 'zig' as const])),
+  ...Object.fromEntries(cpp.extensions.map(e => [e, 'cpp' as const])),
+}
+
+/**
+ * Grammar paths per language
+ */
+export const GRAMMAR_PATHS: Record<Language, string> = {
+  typescript: typescript.grammar,
+  javascript: javascript.grammar,
+  python: python.grammar,
+  rust: rust.grammar,
+  go: go.grammar,
+  zig: zig.grammar,
+  cpp: cpp.grammar,
+}
+
+/**
+ * Node types that represent functions per language
+ */
+export const FUNCTION_TYPES: Record<Language, string[]> = {
+  typescript: typescript.FUNCTION_TYPES,
+  javascript: javascript.FUNCTION_TYPES,
+  python: python.FUNCTION_TYPES,
+  rust: rust.FUNCTION_TYPES,
+  go: go.FUNCTION_TYPES,
+  zig: zig.FUNCTION_TYPES,
+  cpp: cpp.FUNCTION_TYPES,
+}
+
+/**
+ * Node types that represent classes per language
+ */
+export const CLASS_TYPES: Record<Language, string[]> = {
+  typescript: typescript.CLASS_TYPES,
+  javascript: javascript.CLASS_TYPES,
+  python: python.CLASS_TYPES,
+  rust: rust.CLASS_TYPES,
+  go: go.CLASS_TYPES,
+  zig: zig.CLASS_TYPES,
+  cpp: cpp.CLASS_TYPES,
+}
+
+/**
+ * Node types that represent structs per language
+ */
+export const STRUCT_TYPES: Record<Language, string[]> = {
+  typescript: typescript.STRUCT_TYPES,
+  javascript: javascript.STRUCT_TYPES,
+  python: python.STRUCT_TYPES,
+  rust: rust.STRUCT_TYPES,
+  go: go.STRUCT_TYPES,
+  zig: zig.STRUCT_TYPES,
+  cpp: cpp.STRUCT_TYPES,
+}
+
+/**
+ * Node types that represent traits per language
+ */
+export const TRAIT_TYPES: Record<Language, string[]> = {
+  typescript: typescript.TRAIT_TYPES,
+  javascript: javascript.TRAIT_TYPES,
+  python: python.TRAIT_TYPES,
+  rust: rust.TRAIT_TYPES,
+  go: go.TRAIT_TYPES,
+  zig: zig.TRAIT_TYPES,
+  cpp: cpp.TRAIT_TYPES,
+}
+
+/**
+ * Node types that represent interfaces per language
+ */
+export const INTERFACE_TYPES: Record<Language, string[]> = {
+  typescript: typescript.INTERFACE_TYPES,
+  javascript: javascript.INTERFACE_TYPES,
+  python: python.INTERFACE_TYPES,
+  rust: rust.INTERFACE_TYPES,
+  go: go.INTERFACE_TYPES,
+  zig: zig.INTERFACE_TYPES,
+  cpp: cpp.INTERFACE_TYPES,
+}
+
+/**
+ * Node types that represent type aliases per language
+ */
+export const TYPE_TYPES: Record<Language, string[]> = {
+  typescript: typescript.TYPE_TYPES,
+  javascript: javascript.TYPE_TYPES,
+  python: python.TYPE_TYPES,
+  rust: rust.TYPE_TYPES,
+  go: go.TYPE_TYPES,
+  zig: zig.TYPE_TYPES,
+  cpp: cpp.TYPE_TYPES,
+}
+
+/**
+ * Node types that represent enums per language
+ */
+export const ENUM_TYPES: Record<Language, string[]> = {
+  typescript: typescript.ENUM_TYPES,
+  javascript: javascript.ENUM_TYPES,
+  python: python.ENUM_TYPES,
+  rust: rust.ENUM_TYPES,
+  go: go.ENUM_TYPES,
+  zig: zig.ENUM_TYPES,
+  cpp: cpp.ENUM_TYPES,
+}
+
+/**
+ * Node types that represent constants per language
+ */
+export const CONST_TYPES: Record<Language, string[]> = {
+  typescript: typescript.CONST_TYPES,
+  javascript: javascript.CONST_TYPES,
+  python: python.CONST_TYPES,
+  rust: rust.CONST_TYPES,
+  go: go.CONST_TYPES,
+  zig: zig.CONST_TYPES,
+  cpp: cpp.CONST_TYPES,
+}
+
+/**
+ * Extract name from a node using language-specific logic
+ */
+export function extractName(node: SyntaxNode, language: Language): string | null {
+  // Try 'name' field first (common across languages)
+  const nameNode = node.childForFieldName('name')
+  if (nameNode) {
+    return nameNode.text
+  }
+
+  return languages[language].extractName(node)
+}
+
+/**
+ * Extract name from a const/let/var declaration
+ */
+export function extractConstName(node: SyntaxNode, language: Language): string | null {
+  const lang = languages[language]
+  if ('extractConstName' in lang && typeof lang.extractConstName === 'function') {
+    return lang.extractConstName(node)
+  }
+  return extractName(node, language)
+}
+
+/**
+ * Check if a node is exported (language-specific)
+ */
+export function isExported(node: SyntaxNode, language: Language, name?: string): boolean {
+  const lang = languages[language]
+  // Go uses name-based exports
+  if (language === 'go') {
+    return (lang as typeof go).isExported(node, name)
+  }
+  return lang.isExported(node)
+}
+
+/**
+ * Unwrap export statement to get the actual declaration (TS/JS only)
+ */
+export function unwrapExport(node: SyntaxNode, language: Language): SyntaxNode {
+  if (language === 'typescript' || language === 'javascript') {
+    return typescript.unwrapExport(node)
+  }
+  return node
+}
+
+/**
+ * Check if a node has extern modifier (Zig/C++ only)
+ */
+export function isExtern(node: SyntaxNode, language: Language): boolean {
+  if (language === 'zig') {
+    return zig.isExtern(node)
+  }
+  if (language === 'cpp') {
+    return cpp.isExtern(node)
+  }
+  return false
+}
+
+/**
+ * Zig-specific: check if variable_declaration uses 'const'
+ */
+export function isZigConst(node: SyntaxNode): boolean {
+  return zig.isConst(node)
+}
+
+/**
+ * Zig-specific: get type declaration (struct/enum/union) from variable_declaration
+ */
+export function getZigTypeDeclaration(node: SyntaxNode): DefinitionType | null {
+  return zig.getTypeDeclaration(node)
+}

package/src/languages/javascript.ts

@@ -0,0 +1,33 @@
+// JavaScript language support for agentmap.
+// Shares most implementation with TypeScript.
+
+import type { SyntaxNode } from '../types.js'
+import {
+  extractName as tsExtractName,
+  extractConstName as tsExtractConstName,
+  isExported as tsIsExported,
+  unwrapExport as tsUnwrapExport,
+} from './typescript.js'
+
+export const id = 'javascript' as const
+export const extensions = ['.js', '.jsx', '.mjs', '.cjs']
+export const grammar = 'tree-sitter-javascript/tree-sitter-javascript.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_declaration', 'method_definition']
+export const CLASS_TYPES = ['class_declaration']
+export const STRUCT_TYPES: string[] = []
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES: string[] = []
+export const TYPE_TYPES: string[] = []
+export const ENUM_TYPES: string[] = []
+export const CONST_TYPES = ['lexical_declaration']
+
+// Reuse TypeScript implementations
+export const isExported = tsIsExported
+export const unwrapExport = tsUnwrapExport
+export const extractName = tsExtractName
+export const extractConstName = tsExtractConstName
+
+// Comment handling
+export const commentPrefixes = ['//', '/*']

package/src/languages/python.ts

@@ -0,0 +1,41 @@
+// Python language support for agentmap.
+
+import type { SyntaxNode } from '../types.js'
+
+export const id = 'python' as const
+export const extensions = ['.py', '.pyi']
+export const grammar = 'tree-sitter-python/tree-sitter-python.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_definition']
+export const CLASS_TYPES = ['class_definition']
+export const STRUCT_TYPES: string[] = []
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES: string[] = []
+export const TYPE_TYPES: string[] = []
+export const ENUM_TYPES: string[] = []
+export const CONST_TYPES: string[] = []  // Python constants handled separately
+
+/**
+ * Python doesn't have explicit exports - everything is importable
+ */
+export function isExported(_node: SyntaxNode): boolean {
+  return false
+}
+
+/**
+ * Extract name from a Python node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'identifier') {
+      return child.text
+    }
+  }
+  return null
+}
+
+// Comment handling
+export const commentPrefixes = ['#']
+export const docstringType = 'string'  // Python uses docstrings

package/src/languages/rust.ts

@@ -0,0 +1,72 @@
+// Rust language support for agentmap.
+
+import type { SyntaxNode } from '../types.js'
+
+export const id = 'rust' as const
+export const extensions = ['.rs']
+export const grammar = 'tree-sitter-rust/tree-sitter-rust.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_item']
+export const CLASS_TYPES: string[] = []  // Rust has structs/traits, not classes
+export const STRUCT_TYPES = ['struct_item']
+export const TRAIT_TYPES = ['trait_item']
+export const INTERFACE_TYPES: string[] = []  // Rust traits handled in TRAIT_TYPES
+export const TYPE_TYPES = ['type_item']
+export const ENUM_TYPES = ['enum_item']
+export const CONST_TYPES = ['const_item', 'static_item']
+
+/**
+ * Check if a Rust node has 'pub' visibility modifier
+ */
+export function isExported(node: SyntaxNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'visibility_modifier') {
+      return child.text.startsWith('pub')
+    }
+    if (child?.type === 'identifier' || child?.type === 'type_identifier') break
+  }
+  return false
+}
+
+/**
+ * Extract name from a Rust node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  if (node.type === 'impl_item') {
+    const typeNode = node.childForFieldName('type')
+    if (typeNode) {
+      const ident = typeNode.type === 'type_identifier' 
+        ? typeNode 
+        : findChild(typeNode, 'type_identifier')
+      return ident?.text ?? null
+    }
+  }
+  
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'identifier' || child?.type === 'type_identifier') {
+      return child.text
+    }
+  }
+  return null
+}
+
+/**
+ * Extract name from const/static declaration
+ */
+export function extractConstName(node: SyntaxNode): string | null {
+  return extractName(node)
+}
+
+function findChild(node: SyntaxNode, type: string): SyntaxNode | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === type) return child
+  }
+  return null
+}
+
+// Comment handling
+export const commentPrefixes = ['//', '/*', '//!', '///']

package/src/languages/typescript.ts

@@ -0,0 +1,74 @@
+// TypeScript language support for agentmap.
+
+import type { SyntaxNode } from '../types.js'
+
+export const id = 'typescript' as const
+export const extensions = ['.ts', '.tsx', '.mts', '.cts']
+export const grammar = 'tree-sitter-typescript/tree-sitter-tsx.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_declaration', 'method_definition']
+export const CLASS_TYPES = ['class_declaration', 'abstract_class_declaration']
+export const STRUCT_TYPES: string[] = []
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES = ['interface_declaration']
+export const TYPE_TYPES = ['type_alias_declaration']
+export const ENUM_TYPES = ['enum_declaration']
+export const CONST_TYPES = ['lexical_declaration']
+
+/**
+ * Check if a node is an export statement
+ */
+export function isExported(node: SyntaxNode): boolean {
+  return node.type === 'export_statement'
+}
+
+/**
+ * Unwrap export statement to get the actual declaration
+ */
+export function unwrapExport(node: SyntaxNode): SyntaxNode {
+  if (node.type === 'export_statement') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (!child) continue
+      if (child.type !== 'export' && !child.type.includes('comment') && child.type !== 'default') {
+        return child
+      }
+    }
+  }
+  return node
+}
+
+/**
+ * Extract name from a TypeScript/JavaScript node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (!child) continue
+    if (child.type === 'identifier' || child.type === 'type_identifier') {
+      return child.text
+    }
+    if (child.type === 'property_identifier') {
+      return child.text
+    }
+  }
+  return null
+}
+
+/**
+ * Extract name from const/let declaration
+ */
+export function extractConstName(node: SyntaxNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'variable_declarator') {
+      const nameNode = child.childForFieldName('name')
+      return nameNode?.text ?? null
+    }
+  }
+  return null
+}
+
+// Comment handling
+export const commentPrefixes = ['//', '/*']

package/src/languages/zig.ts

@@ -0,0 +1,106 @@
+// Zig language support for agentmap.
+
+import type { SyntaxNode, DefinitionType } from '../types.js'
+
+export const id = 'zig' as const
+export const extensions = ['.zig']
+export const grammar = '@tree-sitter-grammars/tree-sitter-zig/tree-sitter-zig.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_declaration', 'test_declaration']
+export const CLASS_TYPES: string[] = []  // Zig has structs/unions, not classes
+export const STRUCT_TYPES: string[] = []  // Handled via variable_declaration with struct value
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES: string[] = []
+export const TYPE_TYPES: string[] = []
+export const ENUM_TYPES: string[] = []  // Handled via variable_declaration with enum value
+export const CONST_TYPES = ['variable_declaration']
+
+/**
+ * Check if a Zig node has 'pub' modifier
+ */
+export function isExported(node: SyntaxNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'pub') return true
+    if (child?.type === 'identifier' || child?.type === 'block') break
+  }
+  return false
+}
+
+/**
+ * Check if a Zig variable_declaration uses 'const' (not 'var')
+ */
+export function isConst(node: SyntaxNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'const') return true
+    if (child?.type === 'var') return false
+  }
+  return false
+}
+
+/**
+ * Check if a Zig variable_declaration contains a struct/enum/union declaration
+ */
+export function getTypeDeclaration(node: SyntaxNode): DefinitionType | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'struct_declaration') return 'struct'
+    if (child?.type === 'union_declaration') return 'union'
+    if (child?.type === 'enum_declaration') return 'enum'
+  }
+  return null
+}
+
+/**
+ * Check if a Zig function has 'extern' modifier
+ */
+export function isExtern(node: SyntaxNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'extern') return true
+    if (child?.type === 'block' || child?.type === 'fn') break
+  }
+  return false
+}
+
+/**
+ * Extract name from a Zig node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  if (node.type === 'test_declaration') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (child?.type === 'string') {
+        const text = child.text
+        if (text.startsWith('"') && text.endsWith('"')) {
+          return text.slice(1, -1)
+        }
+        return text
+      }
+      if (child?.type === 'identifier') {
+        return child.text
+      }
+    }
+    return null
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'identifier') {
+      return child.text
+    }
+  }
+  return null
+}
+
+/**
+ * Extract name from const/var declaration
+ */
+export function extractConstName(node: SyntaxNode): string | null {
+  return extractName(node)
+}
+
+// Comment handling
+export const commentPrefixes = ['//', '/*']

package/src/logger.ts

@@ -0,0 +1,55 @@
+// Shared logger abstraction used by CLI and integrations.
+
+export interface Logger {
+  debug: (...args: unknown[]) => void
+  info: (...args: unknown[]) => void
+  warn: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+}
+
+const NOOP = () => {}
+
+const NOOP_LOGGER: Logger = {
+  debug: NOOP,
+  info: NOOP,
+  warn: NOOP,
+  error: NOOP,
+}
+
+export function createNoopLogger(): Logger {
+  return NOOP_LOGGER
+}
+
+function formatArg(value: unknown): string {
+  if (typeof value === 'string') {
+    return value
+  }
+
+  if (value instanceof Error) {
+    return value.stack ?? value.message
+  }
+
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+export function formatLogMessage(args: unknown[]): string {
+  return args.map(formatArg).join(' ')
+}
+
+function writeLine(stream: Pick<NodeJS.WriteStream, 'write'>, args: unknown[]): void {
+  const message = formatLogMessage(args)
+  stream.write(message.endsWith('\n') ? message : `${message}\n`)
+}
+
+export function createConsoleLogger(): Logger {
+  return {
+    debug: (...args) => writeLine(process.stderr, args),
+    info: (...args) => writeLine(process.stderr, args),
+    warn: (...args) => writeLine(process.stderr, args),
+    error: (...args) => writeLine(process.stderr, args),
+  }
+}

package/src/map/builder.test.ts

@@ -0,0 +1,72 @@
+// Tests for building nested map nodes for recursive submodule trees.
+
+import { describe, expect, test } from 'bun:test'
+import { buildMap } from './builder.js'
+
+describe('buildMap with recursive submodules', () => {
+  test('renders submodule metadata and nested files under the same node', () => {
+    const map = buildMap(
+      [
+        {
+          relativePath: 'README.md',
+          description: 'Root repo\nRoot README.',
+          definitions: [],
+        },
+        {
+          relativePath: 'vendor/child-lib/README.md',
+          description: 'Child repo\nChild README.',
+          definitions: [],
+        },
+        {
+          relativePath: 'vendor/child-lib/deps/nested-lib/README.md',
+          description: 'Nested repo\nNested README.',
+          definitions: [],
+        },
+      ],
+      'repo',
+      [
+        {
+          path: 'vendor/child-lib',
+          commit: 'abc1234',
+          branch: undefined,
+          dirty: false,
+          initialized: true,
+          url: undefined,
+        },
+        {
+          path: 'vendor/child-lib/deps/nested-lib',
+          commit: 'def5678',
+          branch: undefined,
+          dirty: true,
+          initialized: true,
+          url: undefined,
+        },
+      ]
+    )
+
+    expect(map).toEqual({
+      repo: {
+        'README.md': {
+          description: 'Root repo\nRoot README.',
+        },
+        vendor: {
+          'child-lib': {
+            'README.md': {
+              description: 'Child repo\nChild README.',
+            },
+            deps: {
+              'nested-lib': {
+                'README.md': {
+                  description: 'Nested repo\nNested README.',
+                },
+                dirty: 'modified',
+                submodule: 'detached @ def5678',
+              },
+            },
+            submodule: 'detached @ abc1234',
+          },
+        },
+      },
+    })
+  })
+})