agentmap 0.8.0 → 0.9.0

package/src/extract/submodules.ts

@@ -0,0 +1,269 @@
+// Detect git submodules, their branches, and dirty state.
+// Uses multiple git commands with safeExec for cross-platform reliability.
+
+import { execSync } from 'child_process'
+import { existsSync } from 'fs'
+import { join } from 'path'
+import type { SubmoduleInfo } from '../types.js'
+
+/**
+ * Safely execute a git command, returning empty string on any error
+ */
+function safeExec(cmd: string, dir: string): string {
+  try {
+    return execSync(cmd, {
+      cwd: dir,
+      encoding: 'utf8',
+      maxBuffer: 1024 * 1024 * 10, // 10MB
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * Detect submodule paths by looking for gitlink entries (mode 160000) in git ls-files --stage.
+ * This is the most reliable method - works even if submodules are not initialized.
+ */
+function detectSubmodulePaths(dir: string): Set<string> {
+  const output = safeExec('git ls-files --stage', dir)
+  const paths = new Set<string>()
+
+  if (!output.trim()) return paths
+
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+    // Format: <mode> <hash> <stage>\t<path>
+    // Submodules have mode 160000
+    if (line.startsWith('160000 ')) {
+      const tabIdx = line.indexOf('\t')
+      if (tabIdx !== -1) {
+        paths.add(line.slice(tabIdx + 1).trim())
+      }
+    }
+  }
+
+  return paths
+}
+
+/**
+ * Parse `git submodule status --recursive` output.
+ * Format: " <sha> <path> (<describe>)" or "-<sha> <path>" (uninitialized) or "+<sha> <path> (<describe>)" (out of sync)
+ */
+function parseSubmoduleStatus(dir: string): Map<string, { commit: string; initialized: boolean }> {
+  const output = safeExec('git submodule status --recursive', dir)
+  const result = new Map<string, { commit: string; initialized: boolean }>()
+
+  if (!output.trim()) return result
+
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+
+    // First char: ' ' = OK, '-' = uninitialized, '+' = out of sync, 'U' = merge conflict
+    const prefix = line[0]
+    const initialized = prefix !== '-'
+
+    // Rest: <sha> <path> [(<describe>)]
+    const rest = line.slice(1).trim()
+    const spaceIdx = rest.indexOf(' ')
+    if (spaceIdx === -1) continue
+
+    const commit = rest.slice(0, spaceIdx)
+    let path = rest.slice(spaceIdx + 1)
+
+    // Remove optional describe suffix: " (v1.2.3)" or " (heads/main)"
+    const parenIdx = path.lastIndexOf(' (')
+    if (parenIdx !== -1) {
+      path = path.slice(0, parenIdx)
+    }
+
+    result.set(path.trim(), {
+      commit: commit.slice(0, 7), // short SHA
+      initialized,
+    })
+  }
+
+  return result
+}
+
+/**
+ * Get the checked-out branch for each initialized submodule.
+ * Returns a map of submodule path -> branch name (or undefined for detached HEAD).
+ */
+function getSubmoduleBranches(dir: string): Map<string, string | undefined> {
+  // Use foreach to run git symbolic-ref in each submodule
+  const output = safeExec(
+    'git submodule foreach --quiet --recursive \'echo "$sm_path|$(git symbolic-ref --short -q HEAD 2>/dev/null || echo __detached__)"\'',
+    dir
+  )
+  const result = new Map<string, string | undefined>()
+
+  if (!output.trim()) return result
+
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+    const pipeIdx = line.indexOf('|')
+    if (pipeIdx === -1) continue
+
+    const path = line.slice(0, pipeIdx).trim()
+    const branch = line.slice(pipeIdx + 1).trim()
+
+    result.set(path, branch === '__detached__' || branch === '' ? undefined : branch)
+  }
+
+  return result
+}
+
+/**
+ * Get submodule URLs from .gitmodules config.
+ * Returns a map of submodule path -> URL.
+ */
+function getSubmoduleUrls(dir: string): Map<string, string> {
+  // Check if .gitmodules exists first
+  if (!existsSync(join(dir, '.gitmodules'))) {
+    return new Map()
+  }
+
+  const output = safeExec(
+    'git config -f .gitmodules --get-regexp "^submodule\\..*\\.url$"',
+    dir
+  )
+  const pathOutput = safeExec(
+    'git config -f .gitmodules --get-regexp "^submodule\\..*\\.path$"',
+    dir
+  )
+
+  // Build name -> url map
+  const nameToUrl = new Map<string, string>()
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+    // Format: submodule.<name>.url <url>
+    const match = line.match(/^submodule\.(.+)\.url\s+(.+)$/)
+    if (match) {
+      nameToUrl.set(match[1], match[2].trim())
+    }
+  }
+
+  // Build path -> url map via name -> path mapping
+  const result = new Map<string, string>()
+  for (const line of pathOutput.split('\n')) {
+    if (!line.trim()) continue
+    // Format: submodule.<name>.path <path>
+    const match = line.match(/^submodule\.(.+)\.path\s+(.+)$/)
+    if (match) {
+      const name = match[1]
+      const path = match[2].trim()
+      const url = nameToUrl.get(name)
+      if (url) {
+        result.set(path, url)
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Check which submodules have dirty working trees.
+ * Uses git status --porcelain=2 to detect modified submodule content.
+ *
+ * Porcelain v2 "changed entry" format (type 1):
+ *   1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+ * Fields are space-separated but the path (field 9) may contain spaces,
+ * so we split on the first 8 spaces and take the remainder as the path.
+ */
+function getDirtySubmodules(dir: string, submodulePaths: Set<string>): Set<string> {
+  if (submodulePaths.size === 0) return new Set()
+
+  const output = safeExec('git status --porcelain=2', dir)
+  const dirty = new Set<string>()
+
+  if (!output.trim()) return dirty
+
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+
+    if (line.startsWith('1 ') || line.startsWith('2 ')) {
+      // Split only the first 8 spaces to preserve path with spaces
+      const fields = splitNFields(line, 9)
+      if (fields.length < 9) continue
+
+      // fields[2] is the sub field (N... for non-submodule, S... for submodule)
+      const subField = fields[2]
+      // fields[8] is the full path (may contain spaces)
+      const path = fields[8]
+
+      if (subField && subField.startsWith('S') && subField !== 'S...' && submodulePaths.has(path)) {
+        dirty.add(path)
+      }
+    }
+  }
+
+  return dirty
+}
+
+/**
+ * Split a string into exactly N fields by spaces.
+ * The last field gets the remainder (preserving spaces in paths).
+ */
+function splitNFields(str: string, n: number): string[] {
+  const fields: string[] = []
+  let pos = 0
+  for (let i = 0; i < n - 1 && pos < str.length; i++) {
+    const spaceIdx = str.indexOf(' ', pos)
+    if (spaceIdx === -1) break
+    fields.push(str.slice(pos, spaceIdx))
+    pos = spaceIdx + 1
+  }
+  if (pos < str.length) {
+    fields.push(str.slice(pos))
+  }
+  return fields
+}
+
+/**
+ * Get all submodule info for a repository.
+ * Combines detection, status, branches, URLs, and dirty state.
+ */
+export function getSubmodules(dir: string): SubmoduleInfo[] {
+  // Step 1: Detect all submodule paths (works even if uninitialized)
+  const submodulePaths = detectSubmodulePaths(dir)
+  if (submodulePaths.size === 0) return []
+
+  // Step 2: Get status (commit SHAs and initialized state)
+  const statusMap = parseSubmoduleStatus(dir)
+
+  // Step 3: Get branches for initialized submodules
+  const branchMap = getSubmoduleBranches(dir)
+
+  // Step 4: Get URLs from .gitmodules
+  const urlMap = getSubmoduleUrls(dir)
+
+  // Step 5: Check dirty state
+  const dirtySet = getDirtySubmodules(dir, submodulePaths)
+
+  // Combine all info
+  const submodules: SubmoduleInfo[] = []
+  for (const path of submodulePaths) {
+    const status = statusMap.get(path)
+    submodules.push({
+      path,
+      commit: status?.commit ?? 'unknown',
+      branch: branchMap.get(path),
+      url: urlMap.get(path),
+      dirty: dirtySet.has(path),
+      initialized: status?.initialized ?? false,
+    })
+  }
+
+  return submodules
+}
+
+/**
+ * Get the set of submodule paths for filtering from diff output.
+ * Lightweight version that only detects paths without full info.
+ */
+export function getSubmodulePaths(dir: string): Set<string> {
+  return detectSubmodulePaths(dir)
+}

package/src/extract/utils.ts

@@ -0,0 +1,27 @@
+// Shared utilities for file extraction.
+
+import { open } from 'fs/promises'
+
+/**
+ * Read the first N lines of a file.
+ * Returns null if file cannot be read (ENOENT, permission denied, etc.)
+ */
+export async function readFirstLines(filepath: string, maxLines: number): Promise<string | null> {
+  let handle
+  try {
+    handle = await open(filepath, 'r')
+  } catch {
+    // File doesn't exist or can't be opened - skip silently
+    return null
+  }
+  try {
+    // Read enough bytes for ~maxLines lines (generous estimate)
+    const buffer = Buffer.alloc(maxLines * 200)
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0)
+    const content = buffer.toString('utf8', 0, bytesRead)
+    const lines = content.split('\n').slice(0, maxLines)
+    return lines.join('\n')
+  } finally {
+    await handle.close()
+  }
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+// Library exports for programmatic usage.
+
+import { execSync } from 'child_process'
+import { homedir } from 'os'
+import { resolve } from 'path'
+import { scanDirectory } from './scanner.js'
+import { buildMap, getRootName } from './map/builder.js'
+import { toYaml } from './map/yaml.js'
+import { truncateMap } from './map/truncate.js'
+import type { GenerateOptions, MapNode } from './types.js'
+
+export { toYaml } from './map/yaml.js'
+export { truncateMap, truncateDefs } from './map/truncate.js'
+export type { TruncateOptions } from './map/truncate.js'
+export { createConsoleLogger, createNoopLogger, formatLogMessage } from './logger.js'
+export type { Logger } from './logger.js'
+
+export type {
+  DefEntry,
+  Definition,
+  DefinitionDiff,
+  DefinitionStatus,
+  DiffHunk,
+  FileDiffStats,
+  FileEntry,
+  FileDiff,
+  FileResult,
+  GenerateOptions,
+  Language,
+  MapNode,
+  MarkerResult,
+  SubmoduleEntry,
+  SubmoduleInfo,
+  SubmoduleNode,
+} from './types.js'
+
+/**
+ * Check if directory is inside a git repository
+ */
+export function isGitRepo(dir: string): boolean {
+  try {
+    execSync('git rev-parse --git-dir', { cwd: dir, stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if directory is the user's home directory
+ */
+export function isHomeDirectory(dir: string): boolean {
+  const home = homedir()
+  const resolved = resolve(dir)
+  return resolved === home
+}
+
+const DEFAULT_MAX_DEFS = 25
+
+/**
+ * Generate a map object from a directory
+ * Returns empty map if not in a git repo or if directory is home
+ */
+export async function generateMap(options: GenerateOptions = {}): Promise<MapNode> {
+  const dir = resolve(options.dir ?? '.')
+  const rootName = getRootName(dir)
+
+  // Safety checks - return empty map
+  if (!isGitRepo(dir) || isHomeDirectory(dir)) {
+    return { [rootName]: {} }
+  }
+
+  const { files, submodules } = await scanDirectory({ ...options, dir })
+  const map = buildMap(files, rootName, submodules)
+  
+  // Apply truncation
+  const maxDefs = options.maxDefs ?? DEFAULT_MAX_DEFS
+  return truncateMap(map, { maxDefs, maxDescChars: options.maxDescChars })
+}
+
+/**
+ * Generate a YAML string map from a directory
+ * Returns empty string if not in a git repo or if directory is home
+ */
+export async function generateMapYaml(options: GenerateOptions = {}): Promise<string> {
+  const dir = resolve(options.dir ?? '.')
+
+  // Safety checks - return empty
+  if (!isGitRepo(dir) || isHomeDirectory(dir)) {
+    return ''
+  }
+
+  const { files, submodules } = await scanDirectory({ ...options, dir })
+
+  if (files.length === 0 && submodules.length === 0) {
+    return ''
+  }
+
+  const rootName = getRootName(dir)
+  const map = buildMap(files, rootName, submodules)
+  
+  // Apply truncation
+  const maxDefs = options.maxDefs ?? DEFAULT_MAX_DEFS
+  const truncated = truncateMap(map, { maxDefs, maxDescChars: options.maxDescChars })
+  return toYaml(truncated)
+}

package/src/languages/cpp.ts

@@ -0,0 +1,129 @@
+// C/C++ language support for agentmap.
+
+import type { SyntaxNode } from '../types.js'
+
+export const id = 'cpp' as const
+export const extensions = ['.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx']
+export const grammar = 'tree-sitter-cpp/tree-sitter-cpp.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_definition']
+export const CLASS_TYPES = ['class_specifier']
+export const STRUCT_TYPES = ['struct_specifier']
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES: string[] = []
+export const TYPE_TYPES = ['type_definition', 'alias_declaration']
+export const ENUM_TYPES = ['enum_specifier']
+export const CONST_TYPES = ['declaration']
+
+/**
+ * C++ doesn't have module exports in the traditional sense
+ */
+export function isExported(_node: SyntaxNode): boolean {
+  return false
+}
+
+/**
+ * Check if a C++ node has extern storage class or is in linkage_specification
+ */
+export function isExtern(node: SyntaxNode): boolean {
+  if (node.type === 'declaration' || node.type === 'function_definition') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (child?.type === 'storage_class_specifier' && child.text === 'extern') {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * Extract name from a C++ node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  if (node.type === 'function_definition') {
+    const declarator = node.childForFieldName('declarator')
+    if (declarator) {
+      const funcDecl = declarator.type === 'function_declarator' 
+        ? declarator 
+        : findChild(declarator, 'function_declarator')
+      if (funcDecl) {
+        const innerDecl = funcDecl.childForFieldName('declarator')
+        if (innerDecl?.type === 'identifier') {
+          return innerDecl.text
+        }
+        if (innerDecl?.type === 'qualified_identifier') {
+          const name = innerDecl.childForFieldName('name')
+          return name?.text ?? null
+        }
+      }
+    }
+  }
+
+  if (node.type === 'struct_specifier' || node.type === 'class_specifier' || node.type === 'enum_specifier') {
+    const nameNode = node.childForFieldName('name')
+    if (nameNode) {
+      return nameNode.text
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (child?.type === 'type_identifier') {
+        return child.text
+      }
+    }
+  }
+
+  if (node.type === 'type_definition') {
+    const declarator = node.childForFieldName('declarator')
+    if (declarator?.type === 'type_identifier') {
+      return declarator.text
+    }
+  }
+
+  if (node.type === 'alias_declaration') {
+    const nameNode = node.childForFieldName('name')
+    return nameNode?.text ?? null
+  }
+
+  if (node.type === 'declaration') {
+    const declarator = node.childForFieldName('declarator')
+    if (declarator) {
+      if (declarator.type === 'identifier') {
+        return declarator.text
+      }
+      if (declarator.type === 'init_declarator') {
+        const innerDecl = declarator.childForFieldName('declarator')
+        if (innerDecl?.type === 'identifier') {
+          return innerDecl.text
+        }
+      }
+    }
+  }
+
+  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 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/go.ts

@@ -0,0 +1,72 @@
+// Go language support for agentmap.
+
+import type { SyntaxNode } from '../types.js'
+
+export const id = 'go' as const
+export const extensions = ['.go']
+export const grammar = 'tree-sitter-go/tree-sitter-go.wasm'
+
+// AST node types
+export const FUNCTION_TYPES = ['function_declaration', 'method_declaration']
+export const CLASS_TYPES: string[] = []  // Go has structs, not classes
+export const STRUCT_TYPES: string[] = []  // Go structs handled via type_declaration
+export const TRAIT_TYPES: string[] = []
+export const INTERFACE_TYPES: string[] = []  // Go interfaces handled via type_declaration
+export const TYPE_TYPES = ['type_declaration']
+export const ENUM_TYPES: string[] = []
+export const CONST_TYPES = ['const_declaration', 'var_declaration']
+
+/**
+ * Check if a Go identifier is exported (starts with uppercase)
+ */
+export function isExported(_node: SyntaxNode, name?: string): boolean {
+  if (!name || name.length === 0) return false
+  const firstChar = name.charAt(0)
+  return firstChar >= 'A' && firstChar <= 'Z'
+}
+
+/**
+ * Extract name from a Go node
+ */
+export function extractName(node: SyntaxNode): string | null {
+  if (node.type === 'type_declaration') {
+    const spec = findChild(node, 'type_spec')
+    if (spec) {
+      const nameNode = spec.childForFieldName('name')
+      return nameNode?.text ?? null
+    }
+  }
+  
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'identifier' || child?.type === 'field_identifier') {
+      return child.text
+    }
+  }
+  return null
+}
+
+/**
+ * Extract name from const/var declaration
+ */
+export function extractConstName(node: SyntaxNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)
+    if (child?.type === 'const_spec' || child?.type === 'var_spec') {
+      const nameNode = child.childForFieldName('name')
+      return nameNode?.text ?? null
+    }
+  }
+  return null
+}
+
+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 = ['//', '/*']