ai-codebase-registry 1.0.0

package/lib/generators/side-effects.mjs

@@ -0,0 +1,65 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:gen-side-effects
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 100
+ * @purpose Generates side-effects.json — side-effects graph from @side-effects annotations
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+import { generateSemanticId } from '../core/semantic-id.mjs';
+
+/**
+ * Generate side-effects graph from manifest metadata.
+ *
+ * @param {object} manifest - File manifest with sideEffects field
+ * @returns {object} Side-effects registry
+ */
+export function generateSideEffects(manifest) {
+  const effects = {};
+  const mutations = [];
+  const missingSideEffects = [];
+  let documentedCount = 0;
+
+  for (const [relPath, meta] of Object.entries(manifest)) {
+    const semanticId = meta.id || generateSemanticId(relPath, meta);
+
+    if (meta.sideEffects !== undefined) {
+      documentedCount++;
+      const sideEffectsList = meta.sideEffects === 'none'
+        ? []
+        : meta.sideEffects.split(',').map(s => s.trim()).filter(Boolean);
+
+      effects[semanticId] = {
+        id: semanticId,
+        file: relPath,
+        sideEffects: sideEffectsList,
+        downstreamOf: [],
+      };
+
+      for (const effect of sideEffectsList) {
+        if (effect.startsWith('writes:') || effect.startsWith('triggers:') || effect.startsWith('invalidates:')) {
+          mutations.push({ source: semanticId, effect, file: relPath });
+        }
+      }
+    } else {
+      missingSideEffects.push(relPath);
+    }
+  }
+
+  return {
+    version: '1.0',
+    generated: new Date().toISOString(),
+    documentedCount,
+    missingCount: missingSideEffects.length,
+    effects,
+    mutations,
+    missing_side_effects: missingSideEffects,
+  };
+}

package/lib/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:index
+ * @domain ai-agent-infra
+ * @type index
+ * @side-effects none
+ * @stability high
+ * @complexity trivial
+ * @token-budget 50
+ * @purpose Main entry point for ai-codebase-registry package
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Created package entry point
+ */
+
+export { Registry } from './core/registry.mjs';
+export { loadConfig } from './core/config-loader.mjs';
+export { parseAiMeta } from './core/ai-meta-parser.mjs';
+export { generateSemanticId } from './core/semantic-id.mjs';

package/lib/parsers/imports-typescript.mjs

@@ -0,0 +1,104 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:imports-typescript
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 200
+ * @purpose Parses TypeScript/ESM import and export specifiers from source files; resolves aliases to project paths
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs, parameterized aliases
+ */
+
+import { join, dirname } from 'path';
+
+/**
+ * Extract import/export specifiers from TypeScript/ESM file content.
+ * Returns an array of raw module specifiers.
+ *
+ * @param {string} content - File content
+ * @returns {string[]} Array of module specifiers
+ */
+export function parseImports(content) {
+  const specifiers = new Set();
+
+  // Normalize multi-line imports
+  const normalized = content.replace(/import\s*\{[^}]*\}/gs, (match) =>
+    match.replace(/\n/g, ' ')
+  );
+
+  // Static imports: import ... from '...'
+  const staticRe = /(?:import|export)\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = staticRe.exec(normalized)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  // Side-effect imports: import '...'
+  const sideEffectRe = /import\s+['"]([^'"]+)['"]/g;
+  while ((match = sideEffectRe.exec(normalized)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  // Dynamic imports: import('...')
+  const dynamicRe = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = dynamicRe.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  // Re-exports
+  const reExportRe = /export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g;
+  while ((match = reExportRe.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  return [...specifiers];
+}
+
+/**
+ * Create a module specifier resolver with project-specific aliases.
+ *
+ * @param {object} aliasMap - Map of alias prefixes to target paths
+ * @param {Set<string>} allFilePaths - Set of all known file paths for resolution
+ * @returns {(specifier: string, fromRelPath: string) => string|null}
+ */
+export function createResolver(aliasMap, allFilePaths) {
+  const aliasEntries = Object.entries(aliasMap);
+
+  return function resolveSpecifier(specifier, fromRelPath) {
+    const isAliased = aliasEntries.some(([alias]) => specifier.startsWith(alias));
+    if (!specifier.startsWith('.') && !isAliased) {
+      return null;
+    }
+
+    let basePath;
+
+    for (const [alias, target] of aliasEntries) {
+      if (specifier.startsWith(alias)) {
+        basePath = join(target, specifier.slice(alias.length));
+        break;
+      }
+    }
+
+    if (!basePath && specifier.startsWith('.')) {
+      basePath = join(dirname(fromRelPath), specifier);
+    }
+
+    if (!basePath) return null;
+    basePath = basePath.replace(/\\/g, '/');
+
+    const candidates = [
+      basePath, basePath + '.ts', basePath + '.tsx',
+      basePath + '/index.ts', basePath + '/index.tsx',
+    ];
+
+    for (const c of candidates) {
+      if (allFilePaths.has(c)) return c;
+    }
+
+    return null;
+  };
+}

package/lib/parsers/index.mjs

@@ -0,0 +1,16 @@
+/**
+ * @ai-meta
+ * @id index:ai-agent-infra:parsers-index
+ * @domain ai-agent-infra
+ * @type index
+ * @side-effects none
+ * @stability high
+ * @complexity trivial
+ * @token-budget 20
+ * @purpose Barrel export for all parsers
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Created parsers barrel export
+ */
+
+export { parseImports, createResolver } from './imports-typescript.mjs';

package/lib/query/engine.mjs

@@ -0,0 +1,254 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:query-engine
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability medium
+ * @complexity complex
+ * @token-budget 300
+ * @purpose Query engine for registry data — supports domain/type/impact/coverage/orphaned-routes queries
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Created query engine with all query modes
+ */
+
+import { Registry } from '../core/registry.mjs';
+
+// ANSI colors
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+/**
+ * Execute a query against the registry and return formatted results.
+ *
+ * @param {Registry} registry - Loaded registry instance
+ * @param {object} query - Query parameters
+ * @param {{ json?: boolean }} options
+ * @returns {{ output: string, data: any }}
+ */
+export function executeQuery(registry, query, options = {}) {
+  if (query.help) return formatHelp();
+  if (query.coverage) return formatCoverage(registry, options);
+  if (query.orphanedRoutes) return formatOrphanedRoutes(registry, options);
+  if (query.id) return formatIdLookup(registry, query.id, options);
+  if (query.consumers) return formatConsumers(registry, query.consumers, options);
+  if (query.deps) return formatDeps(registry, query.deps, options);
+  if (query.impact) return formatImpact(registry, query.impact, options);
+  if (query.sideEffects) return formatSideEffects(registry, query.sideEffects, options);
+  if (query.complexity) return formatComplexity(registry, query.complexity, options);
+  if (query.domain) return formatDomainQuery(registry, query.domain, query.type, options);
+  return formatHelp();
+}
+
+function formatHelp() {
+  const output = `
+${C.bold}ai-codebase-registry query${C.reset}
+
+${C.bold}Usage:${C.reset}
+  ai-registry query [options]
+  node scripts/query-registry.mjs [options]
+
+${C.bold}Options:${C.reset}
+  --domain <name>           Filter files by domain
+  --type <type>             Filter files by type (combine with --domain)
+  --id <semantic-id>        Lookup file by semantic ID
+  --consumers <filepath>    Show who imports this file
+  --deps <filepath>         Show what this file imports
+  --impact <filepath>       Full impact analysis for changing a file
+  --side-effects <pattern>  Find files with matching side-effects
+  --complexity <level>      Find files at/above complexity (trivial|moderate|complex)
+  --orphaned-routes         Find routes with no nav entry point
+  --coverage                Show @ai-meta coverage statistics
+  --json                    Output as JSON (for piping)
+  --help                    Show this help
+`;
+  return { output, data: null };
+}
+
+function formatDomainQuery(registry, domain, type, options) {
+  const results = registry.query({ domain, type });
+  if (options.json) return { output: JSON.stringify(results, null, 2), data: results };
+
+  const header = type
+    ? `Registry Query: domain=${domain}, type=${type}`
+    : `Registry Query: domain=${domain}`;
+
+  let output = `\n${C.bold}${header}${C.reset}\n${'='.repeat(header.length)}\n`;
+  for (const r of results) {
+    const purpose = r.purpose ? `  ${C.dim}"${r.purpose}"${C.reset}` : '';
+    output += `  ${C.cyan}${r.path}${C.reset}  ${C.yellow}${r.type}${C.reset}  ${r.size} lines${purpose}\n`;
+  }
+  output += `\n${C.green}Found ${results.length} files${C.reset}\n`;
+  return { output, data: results };
+}
+
+function formatIdLookup(registry, id, options) {
+  const result = registry.resolveWithMeta(id);
+  if (!result) {
+    const output = `${C.red}No file found for semantic ID: ${id}${C.reset}\n`;
+    return { output, data: null };
+  }
+  if (options.json) return { output: JSON.stringify(result, null, 2), data: result };
+
+  let output = `\n${C.bold}Semantic ID: ${id}${C.reset}\n${'='.repeat(40)}\n`;
+  output += `  ${C.cyan}Path:${C.reset}     ${result.path}\n`;
+  output += `  ${C.cyan}Domain:${C.reset}   ${result.domain}\n`;
+  output += `  ${C.cyan}Type:${C.reset}     ${result.type}\n`;
+  output += `  ${C.cyan}Size:${C.reset}     ${result.size} lines\n`;
+  if (result.purpose) output += `  ${C.cyan}Purpose:${C.reset}  ${result.purpose}\n`;
+  if (result.sideEffects) output += `  ${C.cyan}Effects:${C.reset}  ${result.sideEffects}\n`;
+  return { output, data: result };
+}
+
+function formatConsumers(registry, filePath, options) {
+  const consumers = registry.consumers(filePath);
+  if (options.json) return { output: JSON.stringify(consumers, null, 2), data: consumers };
+
+  let output = `\n${C.bold}Consumers of: ${filePath}${C.reset}\n${'='.repeat(50)}\n`;
+  if (consumers.length === 0) {
+    output += `  ${C.dim}No consumers found (not imported by any file)${C.reset}\n`;
+  } else {
+    for (const c of consumers) output += `  ${C.cyan}${c}${C.reset}\n`;
+  }
+  output += `\n${C.green}${consumers.length} direct consumers${C.reset}\n`;
+  return { output, data: consumers };
+}
+
+function formatDeps(registry, filePath, options) {
+  const deps = registry.dependencies(filePath);
+  if (options.json) return { output: JSON.stringify(deps, null, 2), data: deps };
+
+  let output = `\n${C.bold}Dependencies of: ${filePath}${C.reset}\n${'='.repeat(50)}\n`;
+  if (deps.length === 0) {
+    output += `  ${C.dim}No internal dependencies${C.reset}\n`;
+  } else {
+    for (const d of deps) output += `  ${C.cyan}${d}${C.reset}\n`;
+  }
+  output += `\n${C.green}${deps.length} direct dependencies${C.reset}\n`;
+  return { output, data: deps };
+}
+
+function formatImpact(registry, filePath, options) {
+  const impact = registry.impact(filePath);
+  if (options.json) return { output: JSON.stringify(impact, null, 2), data: impact };
+
+  let output = `\n${C.bold}Impact Analysis: ${filePath}${C.reset}\n${'='.repeat(60)}\n`;
+
+  output += `\n${C.bold}Direct consumers (${impact.directConsumers.length}):${C.reset}\n`;
+  for (const c of impact.directConsumers) output += `  ${C.cyan}${c}${C.reset}\n`;
+
+  if (impact.transitiveConsumers.length > 0) {
+    output += `\n${C.bold}Transitive consumers (${impact.transitiveConsumers.length}):${C.reset}\n`;
+    for (const t of impact.transitiveConsumers) output += `  ${C.dim}${t}${C.reset}\n`;
+  }
+
+  if (impact.changeImpactRules.length > 0) {
+    output += `\n${C.bold}Change Impact Rules:${C.reset}\n`;
+    for (const rule of impact.changeImpactRules) {
+      output += `  ${C.yellow}! ${rule.then || rule.description || JSON.stringify(rule)}${C.reset}\n`;
+    }
+  }
+
+  if (impact.sideEffects.length > 0) {
+    output += `\n${C.bold}Side Effects:${C.reset}\n`;
+    for (const e of impact.sideEffects) output += `  ${C.magenta}${e}${C.reset}\n`;
+  }
+
+  const total = impact.directConsumers.length + impact.transitiveConsumers.length;
+  output += `\n${C.green}Total affected: ${total} files${C.reset}\n`;
+  return { output, data: impact };
+}
+
+function formatSideEffects(registry, pattern, options) {
+  const results = [];
+  for (const [id, entry] of Object.entries(registry.sideEffects)) {
+    if (entry.sideEffects.some(e => e.includes(pattern))) {
+      results.push({ id, file: entry.file, sideEffects: entry.sideEffects });
+    }
+  }
+  if (options.json) return { output: JSON.stringify(results, null, 2), data: results };
+
+  let output = `\n${C.bold}Side-effects matching: "${pattern}"${C.reset}\n${'='.repeat(50)}\n`;
+  for (const r of results) {
+    output += `  ${C.cyan}${r.file}${C.reset}  ${C.dim}(${r.id})${C.reset}\n`;
+    for (const e of r.sideEffects) output += `    ${C.magenta}${e}${C.reset}\n`;
+  }
+  output += `\n${C.green}Found ${results.length} files${C.reset}\n`;
+  return { output, data: results };
+}
+
+function formatComplexity(registry, level, options) {
+  const LEVELS = { trivial: 1, moderate: 2, complex: 3 };
+  const threshold = LEVELS[level] || 2;
+  const results = [];
+
+  for (const [path, meta] of Object.entries(registry.manifest)) {
+    // Infer complexity from size if not explicitly set
+    const size = meta.size || 0;
+    let fileComplexity;
+    if (size < 50) fileComplexity = 1;
+    else if (size < 150) fileComplexity = 2;
+    else fileComplexity = 3;
+
+    if (fileComplexity >= threshold) {
+      results.push({ path, size, domain: meta.domain, type: meta.type });
+    }
+  }
+
+  results.sort((a, b) => b.size - a.size);
+  if (options.json) return { output: JSON.stringify(results, null, 2), data: results };
+
+  let output = `\n${C.bold}Files with complexity >= ${level}${C.reset}\n${'='.repeat(50)}\n`;
+  for (const r of results.slice(0, 50)) {
+    output += `  ${C.cyan}${r.path}${C.reset}  ${C.yellow}${r.size} lines${C.reset}  ${r.domain}/${r.type}\n`;
+  }
+  if (results.length > 50) output += `  ${C.dim}... and ${results.length - 50} more${C.reset}\n`;
+  output += `\n${C.green}Found ${results.length} files${C.reset}\n`;
+  return { output, data: results };
+}
+
+function formatOrphanedRoutes(registry, options) {
+  const orphaned = registry.orphanedRoutes();
+  if (options.json) return { output: JSON.stringify(orphaned, null, 2), data: orphaned };
+
+  let output = `\n${C.bold}Orphaned Routes (no nav entry point)${C.reset}\n${'='.repeat(50)}\n`;
+  if (orphaned.length === 0) {
+    output += `  ${C.green}All routes have entry points!${C.reset}\n`;
+  } else {
+    for (const r of orphaned) {
+      output += `  ${C.red}${r.path}${C.reset} -> ${C.cyan}${r.component}${C.reset}\n`;
+      if (r.file) output += `    ${C.dim}${r.file}${C.reset}\n`;
+    }
+  }
+  output += `\n${C.yellow}${orphaned.length} orphaned routes${C.reset}\n`;
+  return { output, data: orphaned };
+}
+
+function formatCoverage(registry, options) {
+  const coverage = registry.coverage();
+  if (options.json) return { output: JSON.stringify(coverage, null, 2), data: coverage };
+
+  let output = `\n${C.bold}Registry Coverage${C.reset}\n${'='.repeat(40)}\n`;
+  output += `  ${C.cyan}Total files:${C.reset}       ${coverage.totalFiles}\n`;
+  output += `  ${C.cyan}With @id:${C.reset}          ${coverage.withId.count} (${coverage.withId.pct}%)\n`;
+  output += `  ${C.cyan}With @side-effects:${C.reset} ${coverage.withSideEffects.count} (${coverage.withSideEffects.pct}%)\n`;
+  output += `  ${C.cyan}With @purpose:${C.reset}     ${coverage.withPurpose.count} (${coverage.withPurpose.pct}%)\n`;
+
+  if (coverage.missingId.length > 0 && coverage.missingId.length <= 20) {
+    output += `\n${C.yellow}Missing @id (${coverage.missingId.length}):${C.reset}\n`;
+    for (const p of coverage.missingId) output += `  ${C.dim}${p}${C.reset}\n`;
+  } else if (coverage.missingId.length > 20) {
+    output += `\n${C.yellow}Missing @id: ${coverage.missingId.length} files (use --json for full list)${C.reset}\n`;
+  }
+
+  return { output, data: coverage };
+}

package/lib/schemas/config.schema.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ai-codebase-registry Config",
+  "type": "object",
+  "required": ["name", "scanDirs"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Project name"
+    },
+    "description": {
+      "type": "string",
+      "description": "Project description"
+    },
+    "scanDirs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["dir"],
+        "properties": {
+          "dir": { "type": "string" },
+          "prefix": { "type": "string" }
+        }
+      },
+      "minItems": 1,
+      "description": "Directories to scan for source files"
+    },
+    "extensions": {
+      "type": "array",
+      "items": { "type": "string" },
+      "default": [".ts", ".tsx"],
+      "description": "File extensions to include"
+    },
+    "skipDirs": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Directory names to skip during scanning"
+    },
+    "aliases": {
+      "type": "object",
+      "additionalProperties": { "type": "string" },
+      "description": "Import alias map (e.g., { '@/': 'src/' })"
+    },
+    "router": {
+      "type": "string",
+      "enum": ["react-router", "nextjs", "expo-router", "express", "none"],
+      "default": "none",
+      "description": "Router framework for route extraction"
+    },
+    "routerEntryFile": {
+      "type": ["string", "null"],
+      "description": "Path to router entry file (e.g., App.tsx)"
+    },
+    "routeBuilderFile": {
+      "type": ["string", "null"],
+      "description": "Path to route builder file (e.g., routes.ts)"
+    },
+    "dataStore": {
+      "type": "string",
+      "enum": ["firestore", "postgres", "mongodb", "none"],
+      "default": "none",
+      "description": "Data store for relationships template"
+    },
+    "registryDir": {
+      "type": "string",
+      "default": "_registry",
+      "description": "Output directory for registry files"
+    },
+    "agent": {
+      "type": "string",
+      "default": "claude-code",
+      "description": "Target AI agent"
+    },
+    "claudemd": {
+      "type": "boolean",
+      "default": true,
+      "description": "Whether to generate/update CLAUDE.md sections"
+    },
+    "rulesFile": {
+      "type": ["string", "null"],
+      "description": "Path to project-specific scoring rules"
+    },
+    "patternsFile": {
+      "type": ["string", "null"],
+      "description": "Path to canonical patterns file"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "ai-codebase-registry",
+  "version": "1.0.0",
+  "description": "Registry-driven AI-agent infrastructure for codebases. Auto-generates machine-readable metadata, dependency graphs, side-effects tracking, and query APIs for AI coding agents. Supports TypeScript, Swift, Kotlin, and Python.",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./core/file-discovery": "./lib/core/file-discovery.mjs",
+    "./core/ai-meta-parser": "./lib/core/ai-meta-parser.mjs",
+    "./core/domain-detector": "./lib/core/domain-detector.mjs",
+    "./core/type-detector": "./lib/core/type-detector.mjs",
+    "./core/semantic-id": "./lib/core/semantic-id.mjs",
+    "./parsers": "./lib/parsers/index.mjs",
+    "./parsers/imports-typescript": "./lib/parsers/imports-typescript.mjs",
+    "./generators": "./lib/generators/index.mjs",
+    "./query": "./lib/query/engine.mjs"
+  },
+  "bin": {
+    "ai-registry": "./bin/cli.mjs",
+    "ai-codebase-registry": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "schemas/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test tests/",
+    "lint": "echo 'no lint configured'"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "codebase",
+    "registry",
+    "metadata",
+    "claude",
+    "ai-meta",
+    "dependency-graph",
+    "side-effects",
+    "swift",
+    "multi-language"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ming0627/bellyfun"
+  }
+}

package/templates/config-swift.mjs

@@ -0,0 +1,27 @@
+/** @type {import('ai-codebase-registry').Config} */
+export default {
+  name: 'my-swift-project',
+  description: 'What this project does',
+
+  scanDirs: [
+    { dir: 'Sources', prefix: 'Sources' },
+    { dir: 'Tests', prefix: 'Tests' },
+  ],
+  extensions: ['.swift'],
+  skipDirs: ['build', '.build', 'Pods', 'DerivedData', 'xcuserdata'],
+
+  language: 'swift',
+  fieldMap: {
+    mutations: 'side-effects',
+    dependencies: 'depends-on',
+  },
+  generators: ['manifest', 'semantic-ids', 'side-effects', 'features'],
+
+  aliases: {},
+  router: 'none',
+  dataStore: 'none', // 'firestore' | 'coredata' | 'realm' | 'none'
+
+  registryDir: '_registry',
+  agent: 'claude-code',
+  claudemd: true,
+};

package/templates/config.mjs

@@ -0,0 +1,25 @@
+/** @type {import('ai-codebase-registry').Config} */
+export default {
+  name: 'my-project',
+  description: 'What this project does',
+
+  scanDirs: [
+    { dir: 'src', prefix: 'src' },
+  ],
+  extensions: ['.ts', '.tsx'],
+  skipDirs: ['node_modules', 'dist', '.next', 'coverage', '__tests__', '__mocks__'],
+
+  aliases: {
+    '@/': 'src/',
+  },
+
+  router: 'none', // 'react-router' | 'nextjs' | 'expo-router' | 'express' | 'none'
+  routerEntryFile: null,
+  routeBuilderFile: null,
+
+  dataStore: 'none', // 'firestore' | 'postgres' | 'mongodb' | 'none'
+
+  registryDir: '_registry',
+  agent: 'claude-code',
+  claudemd: true,
+};