@ulpi/codemap 0.1.0

package/dist/index.js

@@ -0,0 +1,4440 @@
+#!/usr/bin/env node
+import "./chunk-5ISZDDN7.js";
+import "./chunk-WUVKW5JG.js";
+import "./chunk-7SDODQZD.js";
+import "./chunk-SNG7R3UC.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/search.ts
+import chalk from "chalk";
+
+// ../../packages/intelligence/codemap-engine/dist/index.js
+import fs8 from "fs";
+import nodePath from "path";
+
+// ../../packages/foundation/contracts/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z9 } from "zod";
+import { z as z8 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+var EmbeddingProviderSchema = z.enum(["openai", "ollama", "ulpi"]);
+var EmbeddingConfigSchema = z.object({
+  provider: EmbeddingProviderSchema.default("ulpi"),
+  model: z.string().max(100).default("code"),
+  dimensions: z.number().int().positive().max(4096).default(1024),
+  baseUrl: z.string().url().max(200).optional()
+});
+var CodemapChunkingStrategySchema = z2.enum(["sliding-window", "ast"]);
+var CodemapChunkingConfigSchema = z2.object({
+  strategy: CodemapChunkingStrategySchema.default("ast"),
+  windowSize: z2.number().int().positive().max(500).default(60),
+  overlap: z2.number().int().nonnegative().max(100).default(10),
+  maxChunkSize: z2.number().int().positive().max(1e3).default(300),
+  minChunkSize: z2.number().int().positive().max(50).default(5),
+  contextLines: z2.number().int().nonnegative().max(20).default(3),
+  version: z2.number().int().positive().default(2)
+});
+var CodemapBatchConfigSchema = z2.object({
+  size: z2.number().int().positive().max(1e4).default(1e4),
+  debounceMs: z2.number().int().nonnegative().max(3e4).default(500),
+  timeoutMs: z2.number().int().nonnegative().max(36e5).default(6e5),
+  pollIntervalMs: z2.number().int().positive().max(6e4).default(2e3)
+});
+var CodemapHybridWeightsSchema = z2.object({
+  vector: z2.number().min(0).max(1).default(0.6),
+  bm25: z2.number().min(0).max(1).default(0.25),
+  symbolBoost: z2.number().min(0).max(1).default(0.1),
+  pathBoost: z2.number().min(0).max(1).default(0.05),
+  graphRank: z2.number().min(0).max(1).default(0)
+});
+var CodemapHybridConfigSchema = z2.object({
+  enabled: z2.boolean().default(true),
+  vectorK: z2.number().int().positive().max(200).default(30),
+  bm25K: z2.number().int().positive().max(200).default(30),
+  weights: CodemapHybridWeightsSchema.default({})
+});
+var CodemapConfigSchema = z2.object({
+  embedding: EmbeddingConfigSchema.default({}),
+  chunking: CodemapChunkingConfigSchema.default({}),
+  batch: CodemapBatchConfigSchema.default({}),
+  hybrid: CodemapHybridConfigSchema.default({}),
+  deny: z2.array(z2.string().max(500)).max(200).default(["**/.env*", "**/secrets/**", "**/certs/**"]),
+  maxFileSize: z2.number().int().positive().default(1048576),
+  searchTimeoutMs: z2.number().int().positive().default(15e3),
+  autoExport: z2.boolean().default(true),
+  autoImport: z2.boolean().default(true)
+});
+var CodemapSymbolTypeSchema = z2.enum([
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type",
+  "const",
+  "variable",
+  "enum",
+  "unknown"
+]);
+var DepgraphPersonalizationConfigSchema = z3.object({
+  activeFileBoost: z3.number().positive().default(100),
+  mentionedFileBoost: z3.number().positive().default(5),
+  mentionedIdentifierBoost: z3.number().positive().default(10)
+});
+var DepgraphPagerankConfigSchema = z3.object({
+  dampingFactor: z3.number().min(0).max(1).default(0.85),
+  maxIterations: z3.number().int().positive().max(1e4).default(100),
+  convergenceThreshold: z3.number().positive().default(1e-6)
+});
+var DepgraphConfigSchema = z3.object({
+  enabled: z3.boolean().default(true),
+  personalization: DepgraphPersonalizationConfigSchema.default({}),
+  pagerank: DepgraphPagerankConfigSchema.default({}),
+  excludeUnranked: z3.boolean().default(false),
+  excludeUnrankedThreshold: z3.number().nonnegative().default(1e-4)
+});
+var MemoryTypeSchema = z4.enum([
+  "DECISION",
+  "PATTERN",
+  "BUG_ROOT_CAUSE",
+  "PREFERENCE",
+  "CONSTRAINT",
+  "CONTEXT",
+  "LESSON",
+  "RELATIONSHIP"
+]);
+var MemoryImportanceSchema = z4.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var CaptureModeSchema = z4.enum([
+  "continuous",
+  "end_of_session"
+]);
+var MemorySourceSchema = z4.object({
+  type: z4.enum(["explicit", "classifier", "import"]),
+  sessionId: z4.string().max(200).optional(),
+  author: z4.string().max(100).optional()
+});
+var MemoryEntrySchema = z4.object({
+  id: z4.string().max(64),
+  type: MemoryTypeSchema,
+  summary: z4.string().max(2e3),
+  detail: z4.string().max(1e4).nullable().default(null),
+  importance: MemoryImportanceSchema.default("medium"),
+  tags: z4.array(z4.string().max(50)).max(20).default([]),
+  relatedFiles: z4.array(z4.string().max(500)).max(50).default([]),
+  source: MemorySourceSchema,
+  createdAt: z4.string(),
+  updatedAt: z4.string(),
+  accessCount: z4.number().int().nonnegative().default(0),
+  lastAccessedAt: z4.string().optional(),
+  supersededBy: z4.string().max(64).optional()
+});
+var MemoryClassifierConfigSchema = z4.object({
+  enabled: z4.boolean().default(true),
+  model: z4.string().max(100).default("claude-haiku-4-5-20251001"),
+  windowSize: z4.number().int().positive().max(200).default(50),
+  windowOverlap: z4.number().int().nonnegative().max(50).default(10),
+  maxTranscriptChars: z4.number().int().positive().default(2097152),
+  timeout: z4.number().int().positive().default(12e4),
+  includeTranscript: z4.boolean().default(true),
+  maxSinglePromptEvents: z4.number().int().positive().max(500).default(100),
+  minSignificantEvents: z4.number().int().nonnegative().max(50).default(5),
+  filterNoiseEvents: z4.boolean().default(true)
+});
+var MemoryRetentionConfigSchema = z4.object({
+  maxMemories: z4.number().int().positive().max(1e4).default(5e3),
+  maxAgeDays: z4.number().int().positive().default(365),
+  deduplicationThreshold: z4.number().min(0).max(1).default(0.92)
+});
+var MemoryRankingConfigSchema = z4.object({
+  importanceWeights: z4.object({
+    critical: z4.number().min(0).max(1).default(1),
+    high: z4.number().min(0).max(1).default(0.8),
+    medium: z4.number().min(0).max(1).default(0.6),
+    low: z4.number().min(0).max(1).default(0.4)
+  }).default({}),
+  accessBoostPerHit: z4.number().min(0).max(0.1).default(0.05),
+  accessBoostCap: z4.number().min(0).max(1).default(0.2)
+});
+var MemoryPresetSchema = z4.enum(["minimal", "balanced", "thorough"]);
+var MemoryConfigSchema = z4.object({
+  enabled: z4.boolean().default(true),
+  preset: MemoryPresetSchema.optional(),
+  captureMode: CaptureModeSchema.default("continuous"),
+  surfaceOnStart: z4.boolean().default(true),
+  surfaceLimit: z4.number().int().positive().max(20).default(5),
+  embedding: EmbeddingConfigSchema.default({ model: "memory" }),
+  classifier: MemoryClassifierConfigSchema.default({}),
+  retention: MemoryRetentionConfigSchema.default({}),
+  ranking: MemoryRankingConfigSchema.default({}),
+  redactPatterns: z4.array(z4.string().max(500)).max(50).default([]),
+  autoExport: z4.boolean().default(false),
+  reindexBatchSize: z4.number().int().positive().max(500).default(100)
+});
+var ClassificationResultSchema = z4.object({
+  memories: z4.array(z4.object({
+    type: MemoryTypeSchema,
+    summary: z4.string().max(2e3),
+    detail: z4.string().max(1e4).optional(),
+    importance: MemoryImportanceSchema.default("medium"),
+    tags: z4.array(z4.string().max(50)).max(20).default([]),
+    relatedFiles: z4.array(z4.string().max(500)).max(50).default([])
+  })).max(20)
+});
+var BlockTypeSchema = z5.enum([
+  "heading",
+  "paragraph",
+  "code",
+  "list-item",
+  "blockquote",
+  "table",
+  "hr"
+]);
+var BlockSchema = z5.object({
+  id: z5.string().max(200),
+  type: BlockTypeSchema,
+  content: z5.string().max(1e5),
+  level: z5.number().optional(),
+  language: z5.string().max(100).optional(),
+  checked: z5.boolean().optional(),
+  order: z5.number().int(),
+  startLine: z5.number().int()
+});
+var SectionStatusSchema = z5.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "skipped"
+]);
+var PlanSectionSchema = z5.object({
+  id: z5.string().max(200),
+  blockIds: z5.array(z5.string().max(200)),
+  title: z5.string().max(1e3),
+  level: z5.number().int().min(0).max(6),
+  path: z5.string().max(2e3),
+  status: SectionStatusSchema,
+  order: z5.number().int()
+});
+var PriorityLevelSchema = z5.enum([
+  "must-have",
+  "should-have",
+  "nice-to-have",
+  "out-of-scope"
+]);
+var SectionPrioritySchema = z5.object({
+  sectionId: z5.string().max(200),
+  priority: PriorityLevelSchema,
+  note: z5.string().max(5e3).optional()
+});
+var RiskLevelSchema = z5.enum(["low", "medium", "high"]);
+var SectionRiskSchema = z5.object({
+  sectionId: z5.string().max(200),
+  level: RiskLevelSchema,
+  description: z5.string().max(1e4)
+});
+var SectionInstructionSchema = z5.object({
+  id: z5.string().max(200),
+  sectionId: z5.string().max(200),
+  instruction: z5.string().max(1e4),
+  priority: z5.enum(["must", "should", "nice-to-have"]).optional(),
+  createdAt: z5.number(),
+  author: z5.string().max(200).optional()
+});
+var AnnotationTypeSchema = z5.enum([
+  "comment",
+  "suggestion",
+  "concern",
+  "question",
+  "approval",
+  "instruction",
+  "global_comment"
+]);
+var ReviewAnnotationSchema = z5.object({
+  id: z5.string().max(200),
+  type: AnnotationTypeSchema,
+  blockId: z5.string().max(200),
+  sectionId: z5.string().max(200).optional(),
+  startOffset: z5.number().optional(),
+  endOffset: z5.number().optional(),
+  originalText: z5.string().max(5e4),
+  text: z5.string().max(5e4),
+  author: z5.string().max(200).optional(),
+  authorColor: z5.string().max(50).optional(),
+  resolved: z5.boolean().optional(),
+  createdAt: z5.number(),
+  imagePaths: z5.array(z5.string().max(500)).optional()
+});
+var DiffChunkTypeSchema = z5.enum(["equal", "insert", "delete"]);
+var DiffChunkSchema = z5.object({
+  type: DiffChunkTypeSchema,
+  value: z5.string().max(5e5)
+});
+var InlineEditSchema = z5.object({
+  id: z5.string().max(200),
+  blockId: z5.string().max(200),
+  sectionId: z5.string().max(200).optional(),
+  originalContent: z5.string().max(1e5),
+  editedContent: z5.string().max(1e5),
+  characterDiff: z5.array(DiffChunkSchema),
+  author: z5.string().max(200).optional(),
+  createdAt: z5.number()
+});
+var ReviewDecisionSchema = z5.object({
+  behavior: z5.enum(["allow", "deny"]),
+  message: z5.string().max(1e4).optional(),
+  decidedAt: z5.number()
+});
+var RepoInfoSchema = z5.object({
+  remote: z5.string().max(2e3).optional(),
+  branch: z5.string().max(500).optional(),
+  display: z5.string().max(500).optional()
+});
+var PlanStatusSchema = z5.enum([
+  "reviewing",
+  "approved",
+  "denied",
+  "executing",
+  "completed"
+]);
+var TrackerTaskStatusSchema = z6.enum([
+  "open",
+  "in_progress",
+  "done",
+  "failed",
+  "skipped"
+]);
+var TaskPrioritySchema = z6.union([
+  z6.literal(0),
+  z6.literal(1),
+  z6.literal(2),
+  z6.literal(3),
+  z6.literal(4)
+]);
+var TrackerTaskSchema = z6.object({
+  id: z6.string(),
+  title: z6.string(),
+  status: TrackerTaskStatusSchema,
+  priority: TaskPrioritySchema,
+  description: z6.string().optional(),
+  labels: z6.array(z6.string()).optional(),
+  type: z6.string().optional(),
+  parentId: z6.string().optional(),
+  dependsOn: z6.array(z6.string()).optional(),
+  blocks: z6.array(z6.string()).optional(),
+  assignee: z6.string().optional(),
+  createdAt: z6.string().optional(),
+  updatedAt: z6.string().optional(),
+  metadata: z6.record(z6.unknown()).optional()
+});
+var TaskFilterSchema = z6.object({
+  status: z6.union([TrackerTaskStatusSchema, z6.array(TrackerTaskStatusSchema)]).optional(),
+  priority: z6.union([TaskPrioritySchema, z6.array(TaskPrioritySchema)]).optional(),
+  labels: z6.array(z6.string()).optional(),
+  assignee: z6.string().optional(),
+  type: z6.union([z6.string(), z6.array(z6.string())]).optional(),
+  parentId: z6.string().optional(),
+  ready: z6.boolean().optional(),
+  limit: z6.number().int().positive().optional(),
+  offset: z6.number().int().nonnegative().optional(),
+  excludeIds: z6.array(z6.string()).optional()
+});
+var TaskCompletionResultSchema = z6.object({
+  taskId: z6.string(),
+  status: TrackerTaskStatusSchema,
+  summary: z6.string(),
+  filesChanged: z6.array(z6.string()).optional(),
+  commitSha: z6.string().optional()
+});
+var AgentPluginMetaSchema = z6.object({
+  name: z6.string(),
+  version: z6.string(),
+  description: z6.string(),
+  cliCommand: z6.string(),
+  supportsHooks: z6.boolean(),
+  supportsSkills: z6.boolean(),
+  supportsStreaming: z6.boolean(),
+  supportsSubagentTracing: z6.boolean()
+});
+var ExecuteOptionsSchema = z6.object({
+  prompt: z6.string(),
+  workingDir: z6.string(),
+  timeout: z6.number().positive().optional(),
+  env: z6.record(z6.string()).optional(),
+  sandboxConfig: z6.record(z6.unknown()).optional()
+});
+var ExecuteResultSchema = z6.object({
+  exitCode: z6.number(),
+  stdout: z6.string(),
+  stderr: z6.string(),
+  duration: z6.number(),
+  tokenUsage: z6.object({
+    input: z6.number().optional(),
+    output: z6.number().optional()
+  }).optional()
+});
+var TrackerPluginMetaSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string(),
+  version: z6.string(),
+  supportsBidirectionalSync: z6.boolean(),
+  supportsHierarchy: z6.boolean(),
+  supportsDependencies: z6.boolean()
+});
+var SyncResultSchema = z6.object({
+  success: z6.boolean(),
+  message: z6.string(),
+  added: z6.number().optional(),
+  updated: z6.number().optional(),
+  removed: z6.number().optional(),
+  error: z6.string().optional(),
+  syncedAt: z6.string()
+});
+var McpConfigFieldSchema = z7.object({
+  type: z7.enum(["string", "number", "boolean"]).default("string"),
+  format: z7.enum(["env-ref", "plain"]).optional(),
+  required: z7.boolean().default(false),
+  sensitive: z7.boolean().default(false),
+  description: z7.string().optional(),
+  default: z7.union([z7.string(), z7.number(), z7.boolean()]).optional()
+});
+var McpTransportSchema = z7.enum(["stdio", "sse", "http"]).default("stdio");
+var McpCategorySchema = z7.enum([
+  "database",
+  "api",
+  "devtools",
+  "comms",
+  "analytics",
+  "cloud",
+  "ai",
+  "search",
+  "monitoring",
+  "project-management",
+  "design",
+  "custom"
+]).default("custom");
+var McpSourceSchema = z7.enum(["catalog", "manual"]).default("manual");
+var McpDetectSignalsSchema = z7.object({
+  dependencies: z7.array(z7.string()).default([]),
+  env_vars: z7.array(z7.string()).default([]),
+  docker_services: z7.array(z7.string()).default([]),
+  config_files: z7.array(z7.string()).default([])
+}).partial();
+var McpDefinitionSchema = z7.object({
+  name: z7.string().min(1).max(128),
+  display_name: z7.string().max(256).optional(),
+  description: z7.string().max(1024).optional(),
+  command: z7.string().min(1).max(256),
+  args: z7.array(z7.string()).default([]),
+  transport: McpTransportSchema,
+  category: McpCategorySchema,
+  config_schema: z7.record(z7.string(), McpConfigFieldSchema).optional(),
+  tags: z7.array(z7.string()).default([]),
+  source: McpSourceSchema,
+  added_at: z7.string().optional()
+});
+var McpLibrarySchema = z7.object({
+  mcps: z7.record(z7.string(), McpDefinitionSchema).default({})
+});
+var McpActivationSchema = z7.object({
+  enabled: z7.boolean().default(true),
+  config: z7.record(z7.string(), z7.union([z7.string(), z7.number(), z7.boolean()])).default({})
+});
+var McpRepoConfigSchema = z7.object({
+  mcps: z7.record(z7.string(), McpActivationSchema).default({})
+});
+var McpCatalogEntrySchema = McpDefinitionSchema.extend({
+  detect_signals: McpDetectSignalsSchema.optional()
+});
+var McpCatalogSchema = z7.object({
+  catalog: z7.array(McpCatalogEntrySchema).default([])
+});
+var SquadStepSchema = z8.object({
+  name: z8.string(),
+  agent: z8.string(),
+  agentType: z8.string().optional(),
+  model: z8.string().optional(),
+  permissions: z8.enum(["default", "skip", "dangerouslySkip"]).optional(),
+  readOnly: z8.boolean().default(false),
+  systemPrompt: z8.string().optional(),
+  systemPromptFile: z8.string().optional(),
+  timeout: z8.number().int().positive().optional(),
+  canReject: z8.boolean().default(false),
+  rejectTo: z8.string().optional()
+});
+var SquadDefinitionSchema = z8.object({
+  description: z8.string().optional(),
+  steps: z8.array(SquadStepSchema).min(1),
+  maxLoopRounds: z8.number().int().positive().default(3),
+  loopExhaustedBehavior: z8.enum(["fail-task", "merge-with-warning", "skip-remaining"]).default("fail-task"),
+  timeout: z8.number().int().positive().optional()
+});
+var UlpiProjectSchema = z9.object({
+  name: z9.string(),
+  repo: z9.string().optional(),
+  defaultBranch: z9.string().default("main"),
+  targetBranch: z9.string().optional(),
+  // Stack detection fields (ref: StackConfig in template.ts)
+  runtime: z9.string().optional(),
+  language: z9.string().optional(),
+  framework: z9.string().optional(),
+  package_manager: z9.string().optional(),
+  orm: z9.string().optional(),
+  test_runner: z9.string().optional(),
+  formatter: z9.string().optional(),
+  linter: z9.string().optional(),
+  git_workflow: z9.string().optional(),
+  // Command overrides
+  test_command: z9.string().optional(),
+  build_command: z9.string().optional(),
+  lint_command: z9.string().optional(),
+  format_command: z9.string().optional()
+});
+var UlpiPluginsSchema = z9.object({
+  runtime: z9.string().default("tmux"),
+  agent: z9.string().default("claude"),
+  workspace: z9.string().default("worktree"),
+  tracker: z9.string().optional(),
+  scm: z9.string().optional(),
+  notifier: z9.union([z9.string(), z9.array(z9.string())]).optional(),
+  sandbox: z9.string().nullable().optional(),
+  terminal: z9.string().optional(),
+  guard: z9.string().default("default"),
+  model: z9.string().optional()
+});
+var UlpiAgentConfigSchema = z9.object({
+  model: z9.string().optional(),
+  skipPermissions: z9.boolean().optional(),
+  maxTurns: z9.number().int().positive().optional(),
+  timeout: z9.number().int().positive().optional()
+}).passthrough();
+var UlpiFallbackSchema = z9.object({
+  chain: z9.array(z9.string()).default([]),
+  backoffMs: z9.number().int().nonnegative().default(5e3)
+});
+var UlpiSprintSchema = z9.object({
+  maxWorkersPerSprint: z9.number().int().positive().default(3),
+  maxWorkersGlobal: z9.number().int().positive().default(10),
+  maxConcurrentSprints: z9.number().int().positive().default(5),
+  maxRetries: z9.number().int().nonnegative().default(3),
+  timeout: z9.number().int().positive().default(6e5),
+  pollInterval: z9.number().int().positive().default(3e4),
+  branchPrefix: z9.string().default("sprint/")
+});
+var UlpiMergeSchema = z9.object({
+  strategy: z9.enum(["sequential", "rebase", "octopus"]).default("sequential"),
+  conflictResolution: z9.enum(["ai", "manual", "abort"]).default("ai"),
+  enableValidation: z9.boolean().default(true)
+});
+var UlpiGuardsSchema = z9.object({
+  preconditions: z9.record(z9.string(), z9.record(z9.unknown())).default({}),
+  permissions: z9.record(z9.string(), z9.record(z9.unknown())).default({}),
+  postconditions: z9.record(z9.string(), z9.record(z9.unknown())).default({}),
+  pipelines: z9.record(z9.string(), z9.record(z9.unknown())).default({})
+}).passthrough();
+var ReactionTriggerSchema = z9.object({
+  type: z9.enum(["status", "event", "activity"]),
+  to: z9.string().optional(),
+  eventType: z9.string().optional(),
+  state: z9.string().optional(),
+  durationMs: z9.number().int().positive().optional()
+}).passthrough();
+var ReactionActionSchema = z9.object({
+  type: z9.enum(["send_message", "notify", "kill_session", "auto_merge"]),
+  template: z9.string().optional(),
+  urgency: z9.string().optional()
+}).passthrough();
+var EscalationLevelSchema = z9.object({
+  afterMs: z9.number().int().positive(),
+  action: ReactionActionSchema
+});
+var UlpiReactionConfigSchema = z9.object({
+  trigger: ReactionTriggerSchema,
+  action: ReactionActionSchema,
+  cooldownMs: z9.number().int().nonnegative().optional(),
+  maxPerSession: z9.number().int().positive().optional(),
+  enrichWithMemory: z9.boolean().optional(),
+  enrichWithCodemap: z9.boolean().optional(),
+  customPrompt: z9.string().optional(),
+  escalation: z9.object({
+    levels: z9.array(EscalationLevelSchema)
+  }).optional()
+});
+var UlpiNotificationsSchema = z9.object({
+  routing: z9.record(z9.string(), z9.array(z9.string())).optional()
+}).passthrough();
+var UlpiMemorySchema = z9.object({
+  enabled: z9.boolean().default(true),
+  crossAgentSharing: z9.boolean().default(true),
+  autoClassify: z9.boolean().default(true),
+  embedding: z9.object({
+    provider: z9.string().default("openai"),
+    model: z9.string().default("text-embedding-3-small")
+  }).optional()
+});
+var UlpiCodemapSchema = z9.object({
+  enabled: z9.boolean().default(true),
+  embedding: z9.object({
+    provider: z9.string().default("openai"),
+    model: z9.string().default("text-embedding-3-small")
+  }).optional(),
+  watch: z9.boolean().default(true)
+});
+var UlpiBudgetSchema = z9.object({
+  maxCostPerTask: z9.number().nonnegative().optional(),
+  maxCostPerFleet: z9.number().nonnegative().optional(),
+  warnAt: z9.number().min(0).max(1).default(0.8)
+});
+var UlpiConfigSchema = z9.object({
+  project: UlpiProjectSchema,
+  plugins: UlpiPluginsSchema.default({}),
+  agents: z9.record(z9.string(), UlpiAgentConfigSchema).default({}),
+  fallback: UlpiFallbackSchema.default({}),
+  sprint: UlpiSprintSchema.default({}),
+  merge: UlpiMergeSchema.default({}),
+  guards: UlpiGuardsSchema.default({}),
+  reactions: z9.record(z9.string(), UlpiReactionConfigSchema).default({}),
+  notifications: UlpiNotificationsSchema.default({}),
+  memory: UlpiMemorySchema.default({}),
+  codemap: UlpiCodemapSchema.default({}),
+  budget: UlpiBudgetSchema.default({}),
+  squads: z9.record(z9.string(), SquadDefinitionSchema).default({}),
+  agentRules: z9.string().optional()
+});
+var PrdTaskPrioritySchema = z10.enum(["P0", "P1", "P2", "P3"]);
+var PrdTaskTypeSchema = z10.enum([
+  "feature",
+  "bug",
+  "chore",
+  "refactor",
+  "test",
+  "docs",
+  "infra"
+]);
+var PrdTaskSchema = z10.object({
+  id: z10.string(),
+  title: z10.string(),
+  description: z10.string(),
+  priority: PrdTaskPrioritySchema,
+  type: PrdTaskTypeSchema.default("feature"),
+  dependsOn: z10.array(z10.string()).default([]),
+  labels: z10.array(z10.string()).default([]),
+  acceptanceCriteria: z10.array(z10.string()).default([]),
+  effort: z10.enum(["S", "M", "L", "XL"]).optional(),
+  assignee: z10.string().optional(),
+  parentId: z10.string().optional(),
+  sectionPath: z10.array(z10.string()).default([])
+});
+var PrdMetaSchema = z10.object({
+  title: z10.string(),
+  version: z10.string().optional(),
+  author: z10.string().optional(),
+  date: z10.string().optional(),
+  project: z10.string().optional(),
+  tags: z10.array(z10.string()).default([]),
+  frontmatter: z10.record(z10.string()).default({})
+});
+var PrdDocumentSchema = z10.object({
+  meta: PrdMetaSchema,
+  tasks: z10.array(PrdTaskSchema),
+  rawMarkdown: z10.string(),
+  unparsedSections: z10.array(z10.string()).default([])
+});
+var CiCommandTypeSchema = z11.enum([
+  "run",
+  "cancel",
+  "fork",
+  "status",
+  "deploy"
+]);
+var CiCommandSchema = z11.object({
+  type: CiCommandTypeSchema,
+  taskId: z11.string().optional(),
+  taskIds: z11.array(z11.string()).optional(),
+  sprintId: z11.string().optional(),
+  branch: z11.string().optional(),
+  maxWorkers: z11.number().int().positive().optional()
+});
+var CiJobStatusSchema = z11.enum([
+  "queued",
+  "starting",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var CiJobConfigSchema = z11.object({
+  projectId: z11.string(),
+  taskId: z11.string(),
+  branch: z11.string(),
+  prNumber: z11.number().int().optional(),
+  timeout: z11.number().int().positive().optional(),
+  env: z11.record(z11.string()).optional()
+});
+var CiJobResultSchema = z11.object({
+  jobId: z11.string(),
+  status: CiJobStatusSchema,
+  exitCode: z11.number().int().optional(),
+  duration: z11.number().optional(),
+  commitSha: z11.string().optional(),
+  filesChanged: z11.array(z11.string()).optional(),
+  error: z11.string().optional()
+});
+var CiJobSchema = z11.object({
+  id: z11.string(),
+  config: CiJobConfigSchema,
+  status: CiJobStatusSchema,
+  result: CiJobResultSchema.optional(),
+  queuedAt: z11.string(),
+  startedAt: z11.string().optional(),
+  completedAt: z11.string().optional(),
+  workerId: z11.string().optional(),
+  retryCount: z11.number().int().default(0)
+});
+var WorkerInputSchema = z11.object({
+  jobId: z11.string(),
+  taskId: z11.string(),
+  projectId: z11.string(),
+  branch: z11.string(),
+  repoUrl: z11.string(),
+  prompt: z11.string(),
+  env: z11.record(z11.string()).optional(),
+  timeout: z11.number().int().positive().optional()
+});
+var WorkerOutputSchema = z11.object({
+  jobId: z11.string(),
+  exitCode: z11.number().int(),
+  stdout: z11.string(),
+  stderr: z11.string(),
+  duration: z11.number(),
+  commitSha: z11.string().optional(),
+  filesChanged: z11.array(z11.string()).optional()
+});
+var WorkerProgressSchema = z11.object({
+  jobId: z11.string(),
+  phase: z11.string(),
+  progress: z11.number().min(0).max(100),
+  message: z11.string().optional()
+});
+var GitHubAuthConfigSchema = z11.object({
+  appId: z11.number().int().positive().optional(),
+  privateKeyPath: z11.string().optional(),
+  webhookSecret: z11.string(),
+  personalAccessToken: z11.string().optional()
+});
+var DockerConfigSchema = z11.object({
+  image: z11.string().default("ulpi/worker:latest"),
+  memory: z11.string().default("4g"),
+  cpus: z11.number().positive().default(2),
+  network: z11.string().default("ulpi-ci"),
+  volumeMounts: z11.array(z11.string()).optional(),
+  env: z11.record(z11.string()).optional()
+});
+var SecurityConfigSchema = z11.object({
+  allowedRepos: z11.array(z11.string()).default([]),
+  allowedAuthors: z11.array(z11.string()).default([]),
+  requireApproval: z11.boolean().default(false),
+  rateLimitPerRepo: z11.number().int().positive().default(10),
+  rateLimitWindowSeconds: z11.number().int().positive().default(3600)
+});
+var JiraReferenceSchema = z11.object({
+  key: z11.string(),
+  url: z11.string().url().optional()
+});
+var JiraTicketSchema = z11.object({
+  key: z11.string(),
+  summary: z11.string(),
+  status: z11.string(),
+  assignee: z11.string().optional(),
+  url: z11.string().url().optional(),
+  labels: z11.array(z11.string()).default([])
+});
+var ClaudeCredentialsSchema = z11.object({
+  apiKey: z11.string().optional(),
+  maxTokens: z11.number().int().positive().optional(),
+  model: z11.string().optional()
+});
+var AgentCredentialsSchema = z11.object({
+  apiKey: z11.string().optional(),
+  model: z11.string().optional(),
+  maxTokens: z11.number().int().positive().optional()
+});
+var CloudUserSchema = z12.object({
+  id: z12.string().uuid(),
+  github_id: z12.number().int().positive(),
+  email: z12.string().email().optional(),
+  name: z12.string().min(1),
+  avatar_url: z12.string().url().optional(),
+  created_at: z12.string().datetime()
+});
+var CloudOrganizationSchema = z12.object({
+  id: z12.string().uuid(),
+  name: z12.string().min(1),
+  slug: z12.string().min(1),
+  owner_id: z12.string().uuid(),
+  plan: z12.enum(["free", "pro", "enterprise"]).default("free"),
+  created_at: z12.string().datetime()
+});
+var CloudMembershipSchema = z12.object({
+  user_id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  role: z12.enum(["owner", "admin", "member"]),
+  joined_at: z12.string().datetime()
+});
+var CloudPlanTierSchema = z12.enum(["free", "pro", "enterprise"]);
+var CloudSubscriptionSchema = z12.object({
+  id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  plan: CloudPlanTierSchema,
+  status: z12.enum(["active", "past_due", "cancelled", "trialing"]),
+  stripe_subscription_id: z12.string().optional(),
+  current_period_start: z12.string().datetime(),
+  current_period_end: z12.string().datetime()
+});
+var CloudApiKeySchema = z12.object({
+  id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  name: z12.string().min(1),
+  prefix: z12.string(),
+  scopes: z12.array(z12.string()).default([]),
+  created_at: z12.string().datetime(),
+  expires_at: z12.string().datetime().optional(),
+  last_used_at: z12.string().datetime().optional()
+});
+var CloudRepositorySchema = z12.object({
+  id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  github_repo: z12.string(),
+  name: z12.string().min(1),
+  is_active: z12.boolean().default(true),
+  created_at: z12.string().datetime()
+});
+var CloudUsageRecordSchema = z12.object({
+  id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  metric: z12.string(),
+  value: z12.number(),
+  recorded_at: z12.string().datetime()
+});
+var CloudAuditEntrySchema = z12.object({
+  id: z12.string().uuid(),
+  org_id: z12.string().uuid(),
+  actor_id: z12.string().uuid(),
+  action: z12.string(),
+  resource_type: z12.string(),
+  resource_id: z12.string(),
+  metadata: z12.record(z12.unknown()).optional(),
+  created_at: z12.string().datetime()
+});
+
+// ../../packages/foundation/config/dist/index.js
+import { homedir, platform, userInfo } from "os";
+import { basename, join, resolve } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z as z13 } from "zod";
+import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+import { parse as parseYaml4 } from "yaml";
+import { parse as parseYaml5 } from "yaml";
+import { parse as parseYaml6, stringify as stringifyYaml3 } from "yaml";
+import { parse as parseYaml7, stringify as stringifyYaml4 } from "yaml";
+function getDataDir() {
+  return process.env.ULPI_DATA_DIR || `${homedir()}/.ulpi`;
+}
+var ULPI_GLOBAL_DIR = getDataDir();
+var SESSIONS_DIR = join(ULPI_GLOBAL_DIR, "sessions");
+var REVIEWS_DIR = join(ULPI_GLOBAL_DIR, "reviews");
+var REVIEW_FLAGS_DIR = join(ULPI_GLOBAL_DIR, "review-flags");
+var REVIEW_IMAGES_DIR = join(ULPI_GLOBAL_DIR, "review-images");
+var REPOS_FILE = join(ULPI_GLOBAL_DIR, "repos.json");
+var USER_TEMPLATES_DIR = join(ULPI_GLOBAL_DIR, "templates");
+var USER_SKILLS_DIR = join(ULPI_GLOBAL_DIR, "skills");
+var VERSION_CACHE_FILE = join(ULPI_GLOBAL_DIR, ".version-cache.json");
+var SETTINGS_FILE = join(ULPI_GLOBAL_DIR, "settings.json");
+var ULPI_CONFIG_FILE = join(ULPI_GLOBAL_DIR, "config.yml");
+var LOGS_DIR = join(ULPI_GLOBAL_DIR, "logs");
+var NOTIFICATIONS_LOG_FILE = join(ULPI_GLOBAL_DIR, "notifications.log");
+var API_LOCK_FILE = join(ULPI_GLOBAL_DIR, "api.lock");
+var CACHE_DIR = join(ULPI_GLOBAL_DIR, "cache");
+var FLEET_DIR = join(ULPI_GLOBAL_DIR, "fleet");
+var STAGING_DIR = join(ULPI_GLOBAL_DIR, "staging");
+var CODEMAP_DIR_NAME = "codemap";
+var CODEMAP_DIR = join(ULPI_GLOBAL_DIR, CODEMAP_DIR_NAME);
+var MEMORY_DIR = join(ULPI_GLOBAL_DIR, "memory");
+var MCPS_LIBRARY_FILE = join(ULPI_GLOBAL_DIR, "mcps.yml");
+var JOBS_DIR = join(ULPI_GLOBAL_DIR, "jobs");
+function branchToSlug(branch) {
+  const slug = branch.replace(/\//g, "--").replace(/\.\./g, "__").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-{3,}/g, "--").replace(/^-|-$/g, "").toLowerCase();
+  return slug || "main";
+}
+function dirToSlug(dir) {
+  const slug = dir.replace(/^\//, "").replace(/\//g, "-").replace(/\./g, "_").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  return slug || "unknown-project";
+}
+function requireProjectDir(projectDir) {
+  if (!projectDir || !projectDir.trim()) {
+    throw new Error("projectDir must be a non-empty string");
+  }
+  return projectDir;
+}
+function getCurrentBranch(projectDir) {
+  try {
+    const branch = execFileSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: requireProjectDir(projectDir),
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (branch && branch !== "HEAD") return branch;
+  } catch {
+  }
+  return "main";
+}
+function projectCodemapDir(projectDir, dataDir) {
+  return join(dataDir ?? CODEMAP_DIR, dirToSlug(requireProjectDir(projectDir)));
+}
+function codemapBranchDir(projectDir, branch, dataDir) {
+  return join(projectCodemapDir(projectDir, dataDir), branchToSlug(branch));
+}
+function codemapConfigFile(projectDir, dataDir) {
+  return join(projectCodemapDir(projectDir, dataDir), "config.json");
+}
+function codemapStatsFile(projectDir, branch, dataDir) {
+  return join(codemapBranchDir(projectDir, branch, dataDir), "stats.json");
+}
+function codemapLanceDir(projectDir, branch, dataDir) {
+  return join(codemapBranchDir(projectDir, branch, dataDir), "index", "lance");
+}
+function codemapMetadataDir(projectDir, branch, dataDir) {
+  return join(codemapBranchDir(projectDir, branch, dataDir), "index", "metadata");
+}
+function depgraphDir(projectDir, branch, dataDir) {
+  return join(codemapBranchDir(projectDir, branch, dataDir), "index", "metadata", "depgraph");
+}
+function depgraphGraphFile(projectDir, branch, dataDir) {
+  return join(depgraphDir(projectDir, branch, dataDir), "graph.json");
+}
+function depgraphPagerankFile(projectDir, branch, dataDir) {
+  return join(depgraphDir(projectDir, branch, dataDir), "pagerank.json");
+}
+function depgraphMetricsFile(projectDir, branch, dataDir) {
+  return join(depgraphDir(projectDir, branch, dataDir), "metrics.json");
+}
+var CLI_NPM_PACKAGE = "@ulpi/cli";
+var CLI_REGISTRY_URL = `https://registry.npmjs.org/${CLI_NPM_PACKAGE}/latest`;
+var ApiKeysSettingsSchema = z13.object({
+  openai: z13.string().optional(),
+  anthropic: z13.string().optional(),
+  ulpi: z13.string().optional()
+});
+var ReviewSettingsSchema = z13.object({
+  enabled: z13.boolean().default(true),
+  plan_review: z13.boolean().default(true),
+  code_review: z13.boolean().default(true),
+  auto_open_browser: z13.boolean().default(true)
+});
+var UlpiSettingsSchema = z13.object({
+  review: ReviewSettingsSchema.default({}),
+  apiKeys: ApiKeysSettingsSchema.optional(),
+  username: z13.string().optional(),
+  ulpiUrl: z13.string().optional()
+});
+var DashboardAiConfigSchema = z13.object({
+  cli: z13.string(),
+  model: z13.string()
+}).partial();
+var DashboardSettingsSchema = z13.object({
+  prdDefaults: DashboardAiConfigSchema.extend({
+    maxWorkers: z13.number().optional()
+  }).optional(),
+  historyAi: DashboardAiConfigSchema.optional().nullable(),
+  memoryAi: DashboardAiConfigSchema.optional().nullable(),
+  preferences: z13.object({
+    theme: z13.enum(["dark", "light", "system"]).default("dark"),
+    sidebarCollapsed: z13.boolean().default(false),
+    autoRefresh: z13.boolean().default(true),
+    refreshInterval: z13.number().default(5)
+  }).optional()
+}).optional();
+var ProjectSettingsSchema = z13.object({
+  project: z13.object({
+    name: z13.string(),
+    runtime: z13.string().optional(),
+    language: z13.string().optional(),
+    framework: z13.string().optional(),
+    package_manager: z13.string().optional()
+  }).optional(),
+  plugins: z13.object({
+    agent: z13.string().optional()
+  }).passthrough().optional(),
+  agents: z13.record(z13.object({
+    model: z13.string().optional()
+  }).passthrough()).optional(),
+  sprint: z13.object({
+    maxWorkersPerSprint: z13.number().optional()
+  }).passthrough().optional(),
+  notifications: z13.object({
+    enabled: z13.boolean().optional(),
+    desktop: z13.object({ sound: z13.boolean().optional() }).passthrough().optional()
+  }).passthrough().optional(),
+  dashboard: DashboardSettingsSchema,
+  preconditions: z13.record(z13.unknown()).optional(),
+  postconditions: z13.record(z13.unknown()).optional(),
+  permissions: z13.record(z13.unknown()).optional(),
+  pipelines: z13.record(z13.unknown()).optional()
+}).passthrough();
+
+// ../../packages/intelligence/embed-engine/dist/index.js
+async function createEmbedder(config) {
+  switch (config.provider) {
+    case "openai": {
+      const { OpenAIEmbedder: OpenAIEmbedder2 } = await import("./openai-RC75RP4O-NSFZC5O6.js");
+      return new OpenAIEmbedder2(config.model, config.dimensions);
+    }
+    case "ollama": {
+      const { OllamaEmbedder: OllamaEmbedder2 } = await import("./ollama-3XCUZMZT-J6Z4WWWO.js");
+      return new OllamaEmbedder2(config.model, config.dimensions);
+    }
+    case "ulpi": {
+      const { UlpiEmbedder: UlpiEmbedder2 } = await import("./ulpi-KLKEAQC3-5ATUONU7.js");
+      return new UlpiEmbedder2(config.model, config.dimensions, config.baseUrl);
+    }
+    default:
+      throw new Error(`Unknown embedding provider: ${config.provider}`);
+  }
+}
+async function embedOne(embedder, text2) {
+  const [vector] = await embedder.embed([text2]);
+  return vector;
+}
+async function embedAll(embedder, texts, options) {
+  if (texts.length === 0) return [];
+  const {
+    onProgress,
+    onBatch,
+    chunkSize = 100,
+    timeoutMs = 3e5,
+    pollIntervalMs = 2e3,
+    batchSubmitSize = 1e3
+  } = options ?? {};
+  if (embedder.supportsBatch && embedder.submitBatch && embedder.pollBatch) {
+    return embedAllViaBatch(embedder, texts, {
+      onProgress,
+      onBatch,
+      timeoutMs,
+      pollIntervalMs,
+      batchSubmitSize
+    });
+  }
+  return embedAllViaSync(embedder, texts, {
+    onProgress,
+    onBatch,
+    chunkSize
+  });
+}
+async function embedAllViaBatch(embedder, texts, opts) {
+  const { onProgress, onBatch, timeoutMs, pollIntervalMs, batchSubmitSize } = opts;
+  const total = texts.length;
+  const collected = onBatch ? [] : new Array(total);
+  let globalProcessed = 0;
+  const MAX_POLL_ERRORS = 5;
+  for (let offset = 0; offset < total; offset += batchSubmitSize) {
+    const end = Math.min(offset + batchSubmitSize, total);
+    const batchTexts = texts.slice(offset, end);
+    const batchNum = Math.floor(offset / batchSubmitSize) + 1;
+    const totalBatches = Math.ceil(total / batchSubmitSize);
+    onProgress?.({
+      current: globalProcessed,
+      total,
+      message: `Submitting batch ${batchNum}/${totalBatches} (${batchTexts.length} texts)...`
+    });
+    const batchId = await embedder.submitBatch(batchTexts);
+    console.error(
+      `[embed-engine] Batch ${batchNum}/${totalBatches} submitted (${batchId.slice(0, 8)}...), starting poll loop...`
+    );
+    onProgress?.({
+      current: globalProcessed,
+      total,
+      message: `Batch ${batchNum}/${totalBatches} (${batchId.slice(0, 8)}...) polling...`
+    });
+    const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
+    let watermark = 0;
+    let pollCount = 0;
+    let consecutiveErrors = 0;
+    while (deadline === 0 || Date.now() < deadline) {
+      pollCount++;
+      let status;
+      try {
+        status = await embedder.pollBatch(batchId);
+        consecutiveErrors = 0;
+      } catch (err) {
+        consecutiveErrors++;
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(
+          `[embed-engine] Poll error #${consecutiveErrors} for batch ${batchId.slice(0, 8)}...: ${msg}`
+        );
+        if (consecutiveErrors >= MAX_POLL_ERRORS) {
+          throw new Error(
+            `Batch polling failed after ${MAX_POLL_ERRORS} consecutive errors (batch ${batchId}). Last error: ${msg}`
+          );
+        }
+        await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs * 2));
+        continue;
+      }
+      if (status.results && status.results.length > watermark) {
+        const newStart = watermark;
+        const newCount = status.results.length - watermark;
+        const newEmbeddings = status.results.slice(newStart, newStart + newCount);
+        if (onBatch) {
+          await onBatch(newEmbeddings, offset + newStart, newCount);
+        } else {
+          for (let i = 0; i < newCount; i++) {
+            collected[offset + newStart + i] = newEmbeddings[i];
+          }
+        }
+        watermark = status.results.length;
+        console.error(
+          `[embed-engine] Batch ${batchId.slice(0, 8)}... delivered ${watermark}/${batchTexts.length} embeddings`
+        );
+      }
+      if (status.status === "failed") {
+        throw new Error(
+          `Batch embedding failed (batch ${batchId}). ${globalProcessed + watermark} of ${total} texts were processed before failure.`
+        );
+      }
+      const currentProcessed = globalProcessed + watermark;
+      onProgress?.({
+        current: currentProcessed,
+        total,
+        message: `Embedded ${currentProcessed}/${total}`
+      });
+      if (status.status === "completed") {
+        console.error(
+          `[embed-engine] Batch ${batchId.slice(0, 8)}... completed after ${pollCount} polls, ${watermark} embeddings`
+        );
+        break;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
+    }
+    if (watermark < batchTexts.length && deadline > 0 && Date.now() >= deadline) {
+      throw new Error(
+        `Batch embedding timed out after ${Math.round(timeoutMs / 1e3)}s (batch ${batchId}). ${globalProcessed + watermark} of ${total} texts were processed.`
+      );
+    }
+    globalProcessed += batchTexts.length;
+  }
+  console.error(
+    `[embed-engine] All ${Math.ceil(total / batchSubmitSize)} batches complete, ${globalProcessed} embeddings total`
+  );
+  return onBatch ? [] : collected;
+}
+async function embedAllViaSync(embedder, texts, opts) {
+  const { onProgress, onBatch, chunkSize } = opts;
+  const total = texts.length;
+  const collected = [];
+  for (let i = 0; i < total; i += chunkSize) {
+    const chunk = texts.slice(i, i + chunkSize);
+    const embeddings = await embedder.embed(chunk);
+    if (onBatch) {
+      await onBatch(embeddings, i, embeddings.length);
+    } else {
+      collected.push(...embeddings);
+    }
+    const processed = Math.min(i + chunkSize, total);
+    onProgress?.({
+      current: processed,
+      total,
+      message: `Embedded ${processed}/${total}`
+    });
+  }
+  return onBatch ? [] : collected;
+}
+
+// ../../packages/intelligence/codemap-engine/dist/index.js
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { execFileSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import crypto2 from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
+import os from "os";
+import crypto3 from "crypto";
+import fs7 from "fs";
+import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
+import fs10 from "fs";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Images
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".webp",
+  ".avif",
+  ".tiff",
+  // Fonts
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  // Media
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".flac",
+  ".ogg",
+  ".webm",
+  // Archives
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".xz",
+  // Documents
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  // Executables
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".a",
+  ".o",
+  ".class",
+  ".pyc",
+  ".pyo",
+  ".wasm",
+  // Lock files (large, not useful for search)
+  ".lock",
+  // Misc binary
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+  ".bin",
+  ".dat"
+]);
+function loadCodemapIgnore(projectDir) {
+  const ignoreFile = path.join(projectDir, ".codemapignore");
+  try {
+    const raw = fs.readFileSync(ignoreFile, "utf-8");
+    return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+function matchesDenyPattern(filePath, pattern) {
+  const normalized = filePath.replace(/\\/g, "/");
+  let pat = pattern.replace(/\\/g, "/");
+  const isDir = pat.endsWith("/");
+  if (isDir) pat = pat.slice(0, -1);
+  let regex = "";
+  const anchorStart = pat.startsWith("/");
+  if (anchorStart) {
+    regex = "^";
+  } else {
+    regex = "(^|.*/)";
+  }
+  let i = pat.startsWith("/") ? 1 : 0;
+  while (i < pat.length) {
+    if (pat[i] === "*" && pat[i + 1] === "*") {
+      regex += ".*";
+      i += 2;
+      if (pat[i] === "/") i++;
+    } else if (pat[i] === "*") {
+      regex += "[^/]*";
+      i++;
+    } else if (pat[i] === "?") {
+      regex += "[^/]";
+      i++;
+    } else if (pat[i] === ".") {
+      regex += "\\.";
+      i++;
+    } else {
+      regex += pat[i];
+      i++;
+    }
+  }
+  regex += isDir ? "(/.*)?$" : "$";
+  return new RegExp(regex).test(normalized);
+}
+function hashFileContent(filePath) {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function scanRepository(projectDir, config) {
+  const ignorePatterns = loadCodemapIgnore(projectDir);
+  const allDeny = [...config.deny, ...ignorePatterns];
+  let rawFiles;
+  try {
+    rawFiles = execFileSync("git", ["ls-files", "--exclude-standard"], {
+      cwd: projectDir,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    });
+  } catch {
+    rawFiles = "";
+  }
+  const files = rawFiles.split("\n").map((f) => f.trim()).filter((f) => f.length > 0);
+  const results = [];
+  for (const relPath of files) {
+    const ext = path.extname(relPath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) continue;
+    if (allDeny.some((pattern) => matchesDenyPattern(relPath, pattern))) continue;
+    const absPath = path.join(projectDir, relPath);
+    let stat;
+    try {
+      stat = fs.statSync(absPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    if (stat.size === 0) continue;
+    if (stat.size > config.maxFileSize) continue;
+    results.push({
+      filePath: relPath,
+      contentHash: hashFileContent(absPath),
+      mtime: stat.mtimeMs,
+      sizeBytes: stat.size
+    });
+  }
+  results.sort((a, b) => a.filePath.localeCompare(b.filePath));
+  return results;
+}
+var TS_JS_PATTERNS = [
+  { re: /^(?:export\s+)?(?:async\s+)?function\s+\w+/, type: "function" },
+  { re: /^(?:export\s+)?(?:abstract\s+)?class\s+\w+/, type: "class" },
+  { re: /^(?:export\s+)?(?:default\s+)?interface\s+\w+/, type: "class" },
+  { re: /^(?:export\s+)?type\s+\w+\s*=/, type: "block" },
+  { re: /^(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?\(/, type: "function" },
+  { re: /^(?:export\s+)?enum\s+\w+/, type: "block" },
+  { re: /^\s+(?:(?:public|private|protected|static|async|readonly|abstract|override)\s+)*\w+\s*\(/, type: "method" }
+];
+var PYTHON_PATTERNS = [
+  { re: /^(?:async\s+)?def\s+\w+/, type: "function" },
+  { re: /^class\s+\w+/, type: "class" },
+  { re: /^\s+(?:async\s+)?def\s+\w+/, type: "method" }
+];
+var GO_PATTERNS = [
+  { re: /^func\s+(?:\(\w+\s+\*?\w+\)\s+)?\w+/, type: "function" },
+  { re: /^type\s+\w+\s+struct\s*\{/, type: "class" },
+  { re: /^type\s+\w+\s+interface\s*\{/, type: "class" }
+];
+var RUST_PATTERNS = [
+  { re: /^(?:pub(?:\(crate\))?\s+)?(?:async\s+)?fn\s+\w+/, type: "function" },
+  { re: /^(?:pub(?:\(crate\))?\s+)?struct\s+\w+/, type: "class" },
+  { re: /^(?:pub(?:\(crate\))?\s+)?enum\s+\w+/, type: "class" },
+  { re: /^(?:pub(?:\(crate\))?\s+)?trait\s+\w+/, type: "class" },
+  { re: /^impl(?:<[^>]*>)?\s+\w+/, type: "class" }
+];
+var JAVA_PATTERNS = [
+  { re: /^(?:public|private|protected)?\s*(?:static\s+)?(?:abstract\s+)?class\s+\w+/, type: "class" },
+  { re: /^(?:public|private|protected)?\s*(?:static\s+)?interface\s+\w+/, type: "class" },
+  { re: /^(?:public|private|protected)?\s*(?:static\s+)?(?:abstract\s+)?\w+(?:<[^>]*>)?\s+\w+\s*\(/, type: "method" }
+];
+function getPatternsForExt(ext) {
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+    case ".mts":
+    case ".mjs":
+    case ".cts":
+    case ".cjs":
+      return TS_JS_PATTERNS;
+    case ".py":
+    case ".pyi":
+      return PYTHON_PATTERNS;
+    case ".go":
+      return GO_PATTERNS;
+    case ".rs":
+      return RUST_PATTERNS;
+    case ".java":
+    case ".kt":
+    case ".kts":
+      return JAVA_PATTERNS;
+    default:
+      return [];
+  }
+}
+function detectBoundaries(lines, ext) {
+  const patterns = getPatternsForExt(ext);
+  if (patterns.length === 0) return [];
+  const boundaries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+    for (const { re } of patterns) {
+      if (re.test(trimmed)) {
+        boundaries.push(i);
+        break;
+      }
+    }
+  }
+  return boundaries;
+}
+function chunkId(filePath, startLine, endLine) {
+  const hash = crypto2.createHash("sha256").update(`${filePath}:${startLine}:${endLine}`).digest("hex").slice(0, 12);
+  return `${filePath}:${startLine}-${endLine}:${hash}`;
+}
+function chunkHash(content) {
+  return crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function chunkByAST(filePath, lines, config) {
+  const ext = path2.extname(filePath).toLowerCase();
+  const boundaries = detectBoundaries(lines, ext);
+  if (boundaries.length === 0) {
+    return chunkBySlidingWindow(filePath, lines, config);
+  }
+  const chunks = [];
+  for (let i = 0; i < boundaries.length; i++) {
+    const start = Math.max(0, boundaries[i] - config.contextLines);
+    const naturalEnd = (i + 1 < boundaries.length ? boundaries[i + 1] : lines.length) - 1;
+    const end = Math.min(start + config.maxChunkSize - 1, naturalEnd);
+    const content = lines.slice(start, end + 1).join("\n");
+    if (content.trim().length === 0) continue;
+    const lineCount = end - start + 1;
+    if (lineCount < config.minChunkSize && i + 1 < boundaries.length) continue;
+    chunks.push({
+      id: chunkId(filePath, start + 1, end + 1),
+      filePath,
+      startLine: start + 1,
+      endLine: end + 1,
+      content,
+      chunkHash: chunkHash(content)
+    });
+  }
+  if (boundaries[0] > config.contextLines) {
+    const preEnd = boundaries[0] - 1;
+    const preContent = lines.slice(0, preEnd + 1).join("\n");
+    if (preContent.trim().length > 0 && preEnd + 1 >= config.minChunkSize) {
+      chunks.unshift({
+        id: chunkId(filePath, 1, preEnd + 1),
+        filePath,
+        startLine: 1,
+        endLine: preEnd + 1,
+        content: preContent,
+        chunkHash: chunkHash(preContent)
+      });
+    }
+  }
+  return chunks;
+}
+function chunkBySlidingWindow(filePath, lines, config) {
+  const chunks = [];
+  const step = config.windowSize - config.overlap;
+  for (let i = 0; i < lines.length; i += step) {
+    const start = i;
+    const end = Math.min(i + config.windowSize - 1, lines.length - 1);
+    const content = lines.slice(start, end + 1).join("\n");
+    if (content.trim().length === 0) continue;
+    chunks.push({
+      id: chunkId(filePath, start + 1, end + 1),
+      filePath,
+      startLine: start + 1,
+      endLine: end + 1,
+      content,
+      chunkHash: chunkHash(content)
+    });
+    if (end >= lines.length - 1) break;
+  }
+  return chunks;
+}
+function chunkFile(projectDir, filePath, config) {
+  const absPath = path2.join(projectDir, filePath);
+  let content;
+  try {
+    content = fs2.readFileSync(absPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  if (lines.length < config.minChunkSize) {
+    const fullContent = lines.join("\n");
+    if (fullContent.trim().length === 0) return [];
+    return [
+      {
+        id: chunkId(filePath, 1, lines.length),
+        filePath,
+        startLine: 1,
+        endLine: lines.length,
+        content: fullContent,
+        chunkHash: chunkHash(fullContent)
+      }
+    ];
+  }
+  if (config.strategy === "ast") {
+    return chunkByAST(filePath, lines, config);
+  }
+  return chunkBySlidingWindow(filePath, lines, config);
+}
+function chunkFiles(projectDir, filePaths, config) {
+  const allChunks = [];
+  for (const fp of filePaths) {
+    allChunks.push(...chunkFile(projectDir, fp, config));
+  }
+  return allChunks;
+}
+var CodemapStore = class {
+  constructor(lanceDir, dimensions) {
+    this.lanceDir = lanceDir;
+    this.dimensions = dimensions;
+  }
+  db = null;
+  table = null;
+  /**
+   * Initialize the LanceDB connection and open/create the chunks table.
+   */
+  async initialize() {
+    fs3.mkdirSync(this.lanceDir, { recursive: true });
+    const { connect } = await import("@lancedb/lancedb");
+    this.db = await connect(this.lanceDir);
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes("chunks")) {
+      this.table = await this.db.openTable("chunks");
+    }
+  }
+  /**
+   * Drop the existing chunks table (used before full re-index).
+   */
+  async dropTable() {
+    if (!this.db) return;
+    try {
+      const tableNames = await this.db.tableNames();
+      if (tableNames.includes("chunks")) {
+        await this.db.dropTable("chunks");
+      }
+    } catch {
+    }
+    this.table = null;
+  }
+  async reinitialize() {
+    this.table = null;
+    fs3.mkdirSync(this.lanceDir, { recursive: true });
+    const { connect } = await import("@lancedb/lancedb");
+    this.db = await connect(this.lanceDir);
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes("chunks")) {
+      this.table = await this.db.openTable("chunks");
+    }
+  }
+  isCorruptionError(err) {
+    const msg = err.message ?? "";
+    return msg.includes("Not found") || msg.includes("No such file");
+  }
+  /**
+   * Append items to the store (bulk add for initial indexing).
+   */
+  async appendItems(items) {
+    if (!this.db || items.length === 0) return;
+    const rows = items.map((item) => ({
+      id: item.id,
+      vector: item.vector,
+      filePath: item.filePath,
+      startLine: item.startLine,
+      endLine: item.endLine,
+      snippet: item.snippet
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable("chunks", rows);
+    } else {
+      try {
+        await this.table.add(rows);
+      } catch (err) {
+        if (this.isCorruptionError(err)) {
+          await this.reinitialize();
+          this.table = await this.db.createTable("chunks", rows);
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  /**
+   * Upsert items using merge-insert semantics (for incremental updates).
+   */
+  async upsertItems(items) {
+    if (!this.db || items.length === 0) return;
+    if (!this.table) {
+      await this.appendItems(items);
+      return;
+    }
+    const rows = items.map((item) => ({
+      id: item.id,
+      vector: item.vector,
+      filePath: item.filePath,
+      startLine: item.startLine,
+      endLine: item.endLine,
+      snippet: item.snippet
+    }));
+    try {
+      await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(rows);
+    } catch (err) {
+      if (this.isCorruptionError(err)) {
+        await this.reinitialize();
+        this.table = await this.db.createTable("chunks", rows);
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Remove items by chunk IDs.
+   */
+  async removeItems(ids) {
+    if (!this.table || ids.length === 0) return;
+    const BATCH = 500;
+    for (let i = 0; i < ids.length; i += BATCH) {
+      const batch = ids.slice(i, i + BATCH);
+      const escaped = batch.map((id) => `'${id.replace(/'/g, "''")}'`).join(", ");
+      try {
+        await this.table.delete(`id IN (${escaped})`);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Vector similarity search using cosine distance.
+   */
+  async query(vector, topK) {
+    if (!this.table) return [];
+    try {
+      return await this.executeQuery(vector, topK);
+    } catch (err) {
+      if (this.isCorruptionError(err)) {
+        await this.reinitialize();
+        if (!this.table) return [];
+        return this.executeQuery(vector, topK);
+      }
+      throw err;
+    }
+  }
+  async executeQuery(vector, topK) {
+    const q = this.table.search(vector);
+    const vq = q;
+    const results = await vq.distanceType("cosine").limit(topK).toArray();
+    return results.map((row) => ({
+      id: row.id,
+      filePath: row.filePath,
+      startLine: row.startLine,
+      endLine: row.endLine,
+      snippet: row.snippet,
+      score: 1 - row._distance
+    }));
+  }
+  /**
+   * Get the total number of indexed chunks.
+   */
+  async getItemCount() {
+    if (!this.table) return 0;
+    return this.table.countRows();
+  }
+  /**
+   * Get the on-disk size of the index in bytes.
+   */
+  getIndexSizeBytes() {
+    return dirSizeSync(this.lanceDir);
+  }
+  /**
+   * Release native resources.
+   */
+  async close() {
+    this.table = null;
+    this.db = null;
+  }
+};
+function saveSchema(dir, schema) {
+  fs3.mkdirSync(dir, { recursive: true });
+  const file = path3.join(dir, "schema.json");
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs3.writeFileSync(tmp, JSON.stringify(schema, null, 2));
+  fs3.renameSync(tmp, file);
+}
+function dirSizeSync(dir) {
+  let total = 0;
+  try {
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += dirSizeSync(full);
+      } else {
+        total += fs3.statSync(full).size;
+      }
+    }
+  } catch {
+  }
+  return total;
+}
+function chunkToVectorItem(chunk, vector) {
+  return {
+    id: chunk.id,
+    vector,
+    filePath: chunk.filePath,
+    startLine: chunk.startLine,
+    endLine: chunk.endLine,
+    snippet: chunk.content.slice(0, 200)
+  };
+}
+var K1 = 1.2;
+var B = 0.75;
+var MIN_TOKEN_LEN = 2;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "for",
+  "from",
+  "had",
+  "has",
+  "have",
+  "he",
+  "her",
+  "his",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "so",
+  "such",
+  "that",
+  "the",
+  "their",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "to",
+  "was",
+  "which",
+  "with"
+]);
+function tokenize(text2) {
+  return text2.toLowerCase().split(/[^a-z0-9_]+/).filter((t) => t.length >= MIN_TOKEN_LEN && !STOP_WORDS.has(t));
+}
+function buildBM25Index(docs) {
+  const index = {
+    docCount: 0,
+    avgDocLen: 0,
+    df: {},
+    tf: {},
+    docLen: {},
+    docPaths: {}
+  };
+  let totalLen = 0;
+  for (const doc of docs) {
+    const tokens = tokenize(doc.content);
+    index.docCount++;
+    index.docLen[doc.id] = tokens.length;
+    index.docPaths[doc.id] = doc.filePath;
+    totalLen += tokens.length;
+    const termFreq = {};
+    const seen = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreq[token] = (termFreq[token] ?? 0) + 1;
+      if (!seen.has(token)) {
+        seen.add(token);
+        index.df[token] = (index.df[token] ?? 0) + 1;
+      }
+    }
+    index.tf[doc.id] = termFreq;
+  }
+  index.avgDocLen = index.docCount > 0 ? totalLen / index.docCount : 0;
+  return index;
+}
+function addDocuments(index, docs) {
+  let totalLen = index.avgDocLen * index.docCount;
+  for (const doc of docs) {
+    if (index.tf[doc.id]) {
+      removeDocumentInternal(index, doc.id);
+      totalLen = index.avgDocLen * index.docCount;
+    }
+    const tokens = tokenize(doc.content);
+    index.docCount++;
+    index.docLen[doc.id] = tokens.length;
+    index.docPaths[doc.id] = doc.filePath;
+    totalLen += tokens.length;
+    const termFreq = {};
+    const seen = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreq[token] = (termFreq[token] ?? 0) + 1;
+      if (!seen.has(token)) {
+        seen.add(token);
+        index.df[token] = (index.df[token] ?? 0) + 1;
+      }
+    }
+    index.tf[doc.id] = termFreq;
+  }
+  index.avgDocLen = index.docCount > 0 ? totalLen / index.docCount : 0;
+}
+function removeDocuments(index, ids) {
+  for (const id of ids) {
+    removeDocumentInternal(index, id);
+  }
+  const totalLen = Object.values(index.docLen).reduce((sum2, len) => sum2 + len, 0);
+  index.avgDocLen = index.docCount > 0 ? totalLen / index.docCount : 0;
+}
+function removeDocumentInternal(index, id) {
+  const termFreq = index.tf[id];
+  if (!termFreq) return;
+  for (const term of Object.keys(termFreq)) {
+    index.df[term]--;
+    if (index.df[term] <= 0) delete index.df[term];
+  }
+  delete index.tf[id];
+  delete index.docLen[id];
+  delete index.docPaths[id];
+  index.docCount--;
+}
+function queryBM25(index, query, topK) {
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0 || index.docCount === 0) return [];
+  const scores = {};
+  for (const term of queryTokens) {
+    const docFreq = index.df[term];
+    if (!docFreq) continue;
+    const idf = Math.log((index.docCount - docFreq + 0.5) / (docFreq + 0.5) + 1);
+    for (const [docId, termFreq] of Object.entries(index.tf)) {
+      const tf = termFreq[term];
+      if (!tf) continue;
+      const dl = index.docLen[docId];
+      const norm = tf + K1 * (1 - B + B * (dl / index.avgDocLen));
+      const termScore = idf * (tf * (K1 + 1) / norm);
+      scores[docId] = (scores[docId] ?? 0) + termScore;
+    }
+  }
+  return Object.entries(scores).map(([id, score]) => ({ id, filePath: index.docPaths[id], score })).sort((a, b) => b.score - a.score).slice(0, topK);
+}
+function saveBM25Index(metadataDir, index) {
+  fs4.mkdirSync(metadataDir, { recursive: true });
+  const file = path4.join(metadataDir, "bm25.json");
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs4.writeFileSync(tmp, JSON.stringify(index));
+  fs4.renameSync(tmp, file);
+}
+function loadBM25Index(metadataDir) {
+  const file = path4.join(metadataDir, "bm25.json");
+  try {
+    return JSON.parse(fs4.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var TS_JS_SYMBOLS = [
+  { re: /(?:export\s+)?(?:async\s+)?function\s+(\w+)/g, type: "function", nameGroup: 1 },
+  { re: /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/g, type: "class", nameGroup: 1 },
+  { re: /(?:export\s+)?(?:default\s+)?interface\s+(\w+)/g, type: "interface", nameGroup: 1 },
+  { re: /(?:export\s+)?type\s+(\w+)\s*=/g, type: "type", nameGroup: 1 },
+  { re: /(?:export\s+)?enum\s+(\w+)/g, type: "enum", nameGroup: 1 },
+  { re: /(?:export\s+)?const\s+(\w+)\s*=/g, type: "const", nameGroup: 1 },
+  { re: /(?:export\s+)?(?:let|var)\s+(\w+)\s*=/g, type: "variable", nameGroup: 1 }
+];
+var PYTHON_SYMBOLS = [
+  { re: /(?:async\s+)?def\s+(\w+)/g, type: "function", nameGroup: 1 },
+  { re: /class\s+(\w+)/g, type: "class", nameGroup: 1 }
+];
+var GO_SYMBOLS = [
+  { re: /func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)/g, type: "function", nameGroup: 1 },
+  { re: /type\s+(\w+)\s+struct/g, type: "class", nameGroup: 1 },
+  { re: /type\s+(\w+)\s+interface/g, type: "interface", nameGroup: 1 }
+];
+var RUST_SYMBOLS = [
+  { re: /(?:pub(?:\(crate\))?\s+)?(?:async\s+)?fn\s+(\w+)/g, type: "function", nameGroup: 1 },
+  { re: /(?:pub(?:\(crate\))?\s+)?struct\s+(\w+)/g, type: "class", nameGroup: 1 },
+  { re: /(?:pub(?:\(crate\))?\s+)?enum\s+(\w+)/g, type: "enum", nameGroup: 1 },
+  { re: /(?:pub(?:\(crate\))?\s+)?trait\s+(\w+)/g, type: "interface", nameGroup: 1 }
+];
+var JAVA_SYMBOLS = [
+  { re: /(?:public|private|protected)?\s*(?:static\s+)?(?:abstract\s+)?class\s+(\w+)/g, type: "class", nameGroup: 1 },
+  { re: /(?:public|private|protected)?\s*(?:static\s+)?interface\s+(\w+)/g, type: "interface", nameGroup: 1 },
+  { re: /(?:public|private|protected)?\s*(?:static\s+)?enum\s+(\w+)/g, type: "enum", nameGroup: 1 }
+];
+function getSymbolPatterns(ext) {
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+    case ".mts":
+    case ".mjs":
+    case ".cts":
+    case ".cjs":
+      return TS_JS_SYMBOLS;
+    case ".py":
+    case ".pyi":
+      return PYTHON_SYMBOLS;
+    case ".go":
+      return GO_SYMBOLS;
+    case ".rs":
+      return RUST_SYMBOLS;
+    case ".java":
+    case ".kt":
+    case ".kts":
+      return JAVA_SYMBOLS;
+    default:
+      return [];
+  }
+}
+function extractSymbols(chunk) {
+  const ext = path5.extname(chunk.filePath).toLowerCase();
+  const patterns = getSymbolPatterns(ext);
+  if (patterns.length === 0) return [];
+  const symbols = [];
+  const lines = chunk.content.split("\n");
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    for (const { re, type, nameGroup } of patterns) {
+      re.lastIndex = 0;
+      let match;
+      while ((match = re.exec(line)) !== null) {
+        const name = match[nameGroup];
+        if (!name || name.length < 2) continue;
+        symbols.push({
+          name,
+          symbolType: type,
+          filePath: chunk.filePath,
+          startLine: chunk.startLine + lineIdx,
+          endLine: chunk.endLine,
+          chunkId: chunk.id
+        });
+      }
+    }
+  }
+  return symbols;
+}
+function extractSymbolsFromChunks(chunks) {
+  const seen = /* @__PURE__ */ new Set();
+  const allSymbols = [];
+  for (const chunk of chunks) {
+    const symbols = extractSymbols(chunk);
+    for (const sym of symbols) {
+      const key = `${sym.name}:${sym.filePath}:${sym.startLine}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      allSymbols.push(sym);
+    }
+  }
+  return allSymbols;
+}
+function searchSymbols(symbols, query, topK = 20) {
+  const q = query.toLowerCase();
+  const results = [];
+  for (const entry of symbols) {
+    const name = entry.name.toLowerCase();
+    let score = 0;
+    if (name === q) {
+      score = 1;
+    } else if (name.startsWith(q)) {
+      score = 0.8;
+    } else if (name.includes(q)) {
+      score = 0.5;
+    } else {
+      continue;
+    }
+    results.push({ entry, score });
+  }
+  results.sort((a, b) => b.score - a.score || a.entry.name.localeCompare(b.entry.name));
+  return results.slice(0, topK);
+}
+function saveSymbolIndex(metadataDir, symbols) {
+  fs5.mkdirSync(metadataDir, { recursive: true });
+  const file = path5.join(metadataDir, "symbols.jsonl");
+  const tmp = `${file}.${process.pid}.tmp`;
+  const content = symbols.map((s) => JSON.stringify(s)).join("\n");
+  fs5.writeFileSync(tmp, content);
+  fs5.renameSync(tmp, file);
+}
+function loadSymbolIndex(metadataDir) {
+  const file = path5.join(metadataDir, "symbols.jsonl");
+  try {
+    const raw = fs5.readFileSync(file, "utf-8");
+    return raw.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+var POLL_MS = 500;
+var ACQUIRE_TIMEOUT_MS = 1e4;
+var STALE_TIMEOUT_MS = 6e4;
+function lockPath(projectDir, branch) {
+  const projHash = crypto3.createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
+  const branchHash = crypto3.createHash("sha256").update(branch).digest("hex").slice(0, 12);
+  return path6.join(os.tmpdir(), `ulpi-codemap-${projHash}-${branchHash}.lock`);
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readLock(file) {
+  try {
+    const raw = fs6.readFileSync(file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isStale(info) {
+  if (!isPidAlive(info.pid)) return true;
+  return Date.now() - info.timestamp > STALE_TIMEOUT_MS;
+}
+async function acquireCodemapLock(projectDir, branch, timeoutMs = ACQUIRE_TIMEOUT_MS) {
+  const file = lockPath(projectDir, branch);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const fd = fs6.openSync(file, "wx");
+      const info = { pid: process.pid, timestamp: Date.now() };
+      fs6.writeSync(fd, JSON.stringify(info));
+      fs6.closeSync(fd);
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const existing = readLock(file);
+    if (existing && isStale(existing)) {
+      try {
+        fs6.unlinkSync(file);
+      } catch {
+      }
+      continue;
+    }
+    await new Promise((r) => setTimeout(r, POLL_MS));
+  }
+  throw new Error(`Failed to acquire codemap lock within ${timeoutMs}ms (${file})`);
+}
+function releaseCodemapLock(projectDir, branch) {
+  const file = lockPath(projectDir, branch);
+  const info = readLock(file);
+  if (!info || info.pid !== process.pid) return;
+  try {
+    fs6.unlinkSync(file);
+  } catch {
+  }
+}
+function saveManifest(branchDir, manifest) {
+  fs7.mkdirSync(branchDir, { recursive: true });
+  const file = path7.join(branchDir, "manifest.json");
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs7.writeFileSync(tmp, JSON.stringify(manifest, null, 2));
+  fs7.renameSync(tmp, file);
+}
+function loadManifest(branchDir) {
+  const file = path7.join(branchDir, "manifest.json");
+  try {
+    return JSON.parse(fs7.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function createManifest(chunkerVersion) {
+  return {
+    version: 1,
+    chunkerVersion,
+    files: {}
+  };
+}
+function diffManifest(manifest, scannedFiles) {
+  const added = [];
+  const changed = [];
+  const removed = [];
+  const currentPaths = new Set(scannedFiles.map((f) => f.filePath));
+  const manifestFiles = manifest?.files ?? {};
+  for (const file of scannedFiles) {
+    const existing = manifestFiles[file.filePath];
+    if (!existing) {
+      added.push(file);
+    } else if (existing.contentHash !== file.contentHash) {
+      changed.push(file);
+    }
+  }
+  for (const filePath of Object.keys(manifestFiles)) {
+    if (!currentPaths.has(filePath)) {
+      removed.push(filePath);
+    }
+  }
+  return { added, changed, removed };
+}
+function updateManifestEntries(manifest, files, chunkIds) {
+  for (const file of files) {
+    manifest.files[file.filePath] = {
+      contentHash: file.contentHash,
+      mtime: file.mtime,
+      sizeBytes: file.sizeBytes,
+      chunkIds: chunkIds.get(file.filePath) ?? []
+    };
+  }
+}
+function removeManifestEntries(manifest, filePaths) {
+  const removedChunkIds = [];
+  for (const fp of filePaths) {
+    const entry = manifest.files[fp];
+    if (entry) {
+      removedChunkIds.push(...entry.chunkIds);
+      delete manifest.files[fp];
+    }
+  }
+  return removedChunkIds;
+}
+var STORE_BATCH_SIZE = 100;
+async function runInitPipeline(projectDir, config, options) {
+  const cfg = CodemapConfigSchema.parse(config ?? {});
+  const branch = options?.branch ?? "main";
+  const onProgress = options?.onProgress;
+  const dataDir = options?.dataDir;
+  await acquireCodemapLock(projectDir, branch);
+  try {
+    return await runInitPipelineInner(projectDir, cfg, branch, onProgress, dataDir);
+  } finally {
+    releaseCodemapLock(projectDir, branch);
+  }
+}
+async function runInitPipelineInner(projectDir, config, branch, onProgress, dataDir) {
+  const startMs = Date.now();
+  const lanceDir = codemapLanceDir(projectDir, branch, dataDir);
+  const metadataDir = codemapMetadataDir(projectDir, branch, dataDir);
+  const branchDir = codemapBranchDir(projectDir, branch, dataDir);
+  onProgress?.({ phase: "scanning", message: "Scanning repository..." });
+  const scannedFiles = scanRepository(projectDir, config);
+  onProgress?.({
+    phase: "scanning",
+    message: `Found ${scannedFiles.length} files`,
+    current: scannedFiles.length,
+    total: scannedFiles.length
+  });
+  if (scannedFiles.length === 0) {
+    return emptyStats();
+  }
+  onProgress?.({ phase: "chunking", message: "Chunking files..." });
+  const allChunks = chunkFiles(
+    projectDir,
+    scannedFiles.map((f) => f.filePath),
+    config.chunking
+  );
+  onProgress?.({
+    phase: "chunking",
+    message: `Generated ${allChunks.length} chunks from ${scannedFiles.length} files`,
+    current: allChunks.length,
+    total: allChunks.length
+  });
+  const embedder = await createEmbedder(config.embedding);
+  const store = new CodemapStore(lanceDir, embedder.dimensions);
+  await store.initialize();
+  await store.dropTable();
+  await embedAndStore(embedder, store, allChunks, onProgress);
+  onProgress?.({ phase: "symbols", message: "Extracting symbols..." });
+  const symbols = extractSymbolsFromChunks(allChunks);
+  saveSymbolIndex(metadataDir, symbols);
+  onProgress?.({
+    phase: "symbols",
+    message: `Extracted ${symbols.length} symbols`,
+    current: symbols.length,
+    total: symbols.length
+  });
+  onProgress?.({ phase: "bm25", message: "Building BM25 index..." });
+  const bm25Docs = allChunks.map((c) => ({
+    id: c.id,
+    filePath: c.filePath,
+    content: c.content
+  }));
+  const bm25Index = buildBM25Index(bm25Docs);
+  saveBM25Index(metadataDir, bm25Index);
+  onProgress?.({ phase: "finalizing", message: "Saving metadata..." });
+  const manifest = createManifest(config.chunking.version);
+  const chunkIdsByFile = groupChunkIdsByFile(allChunks);
+  updateManifestEntries(manifest, scannedFiles, chunkIdsByFile);
+  saveManifest(branchDir, manifest);
+  const schema = {
+    formatVersion: 1,
+    vectorStore: { engine: "lancedb", dimensions: embedder.dimensions },
+    embedding: { provider: embedder.provider, model: embedder.model },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveSchema(branchDir, schema);
+  saveCodemapConfig(projectDir, config, dataDir);
+  const stats = {
+    totalFiles: scannedFiles.length,
+    totalChunks: allChunks.length,
+    staleFiles: 0,
+    indexSizeBytes: store.getIndexSizeBytes(),
+    lastFullIndexMs: Date.now() - startMs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveStats(branchDir, stats);
+  await store.close();
+  onProgress?.({
+    phase: "finalizing",
+    message: `Indexed ${stats.totalFiles} files, ${stats.totalChunks} chunks in ${stats.lastFullIndexMs}ms`
+  });
+  return stats;
+}
+async function runIncrementalPipeline(projectDir, changedPaths, options) {
+  const branch = options?.branch ?? "main";
+  const dataDir = options?.dataDir;
+  const branchDir = codemapBranchDir(projectDir, branch, dataDir);
+  const onProgress = options?.onProgress;
+  const config = loadConfig(projectDir, dataDir);
+  const manifest = loadManifest(branchDir);
+  if (!manifest) {
+    return runInitPipeline(projectDir, config, options);
+  }
+  await acquireCodemapLock(projectDir, branch);
+  try {
+    return await runIncrementalInner(projectDir, config, branch, manifest, changedPaths, onProgress, dataDir);
+  } finally {
+    releaseCodemapLock(projectDir, branch);
+  }
+}
+async function runIncrementalInner(projectDir, config, branch, manifest, changedPaths, onProgress, dataDir) {
+  const startMs = Date.now();
+  const lanceDir = codemapLanceDir(projectDir, branch, dataDir);
+  const metadataDir = codemapMetadataDir(projectDir, branch, dataDir);
+  const branchDir = codemapBranchDir(projectDir, branch, dataDir);
+  onProgress?.({ phase: "scanning", message: "Scanning for changes..." });
+  const scannedFiles = scanRepository(projectDir, config);
+  const diff = diffManifest(manifest, scannedFiles);
+  if (changedPaths && changedPaths.length > 0) {
+    const changedSet = new Set(changedPaths);
+    diff.added = diff.added.filter((f) => changedSet.has(f.filePath));
+    diff.changed = diff.changed.filter((f) => changedSet.has(f.filePath));
+    diff.removed = diff.removed.filter((fp) => changedSet.has(fp));
+  }
+  const totalChanges = diff.added.length + diff.changed.length + diff.removed.length;
+  if (totalChanges === 0) {
+    onProgress?.({ phase: "finalizing", message: "No changes detected" });
+    return loadStats(branchDir) ?? emptyStats();
+  }
+  onProgress?.({
+    phase: "scanning",
+    message: `Found ${diff.added.length} added, ${diff.changed.length} changed, ${diff.removed.length} removed`
+  });
+  const embedder = await createEmbedder(config.embedding);
+  const store = new CodemapStore(lanceDir, embedder.dimensions);
+  await store.initialize();
+  const filesToRemove = [...diff.changed.map((f) => f.filePath), ...diff.removed];
+  const removedChunkIds = removeManifestEntries(manifest, filesToRemove);
+  if (removedChunkIds.length > 0) {
+    await store.removeItems(removedChunkIds);
+  }
+  const filesToIndex = [...diff.added, ...diff.changed];
+  if (filesToIndex.length > 0) {
+    onProgress?.({ phase: "chunking", message: `Chunking ${filesToIndex.length} files...` });
+    const newChunks = chunkFiles(
+      projectDir,
+      filesToIndex.map((f) => f.filePath),
+      config.chunking
+    );
+    await embedAndStore(embedder, store, newChunks, onProgress);
+    const chunkIdsByFile = groupChunkIdsByFile(newChunks);
+    updateManifestEntries(manifest, filesToIndex, chunkIdsByFile);
+    const bm25Index = loadBM25Index(metadataDir) ?? buildBM25Index([]);
+    if (removedChunkIds.length > 0) {
+      removeDocuments(bm25Index, removedChunkIds);
+    }
+    addDocuments(
+      bm25Index,
+      newChunks.map((c) => ({ id: c.id, filePath: c.filePath, content: c.content }))
+    );
+    saveBM25Index(metadataDir, bm25Index);
+    const allFilePaths = scannedFiles.map((f) => f.filePath);
+    const allChunks = chunkFiles(projectDir, allFilePaths, config.chunking);
+    const symbols = extractSymbolsFromChunks(allChunks);
+    saveSymbolIndex(metadataDir, symbols);
+  } else {
+    const bm25Index = loadBM25Index(metadataDir);
+    if (bm25Index && removedChunkIds.length > 0) {
+      removeDocuments(bm25Index, removedChunkIds);
+      saveBM25Index(metadataDir, bm25Index);
+    }
+  }
+  saveManifest(branchDir, manifest);
+  const stats = {
+    totalFiles: Object.keys(manifest.files).length,
+    totalChunks: await store.getItemCount(),
+    staleFiles: 0,
+    indexSizeBytes: store.getIndexSizeBytes(),
+    lastFullIndexMs: Date.now() - startMs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveStats(branchDir, stats);
+  await store.close();
+  onProgress?.({
+    phase: "finalizing",
+    message: `Incremental update: ${totalChanges} changes processed in ${stats.lastFullIndexMs}ms`
+  });
+  return stats;
+}
+async function embedAndStore(embedder, store, chunks, onProgress) {
+  if (chunks.length === 0) return;
+  const texts = chunks.map((c) => buildEmbeddingText(c));
+  onProgress?.({
+    phase: "embedding",
+    message: `Embedding ${chunks.length} chunks...`,
+    current: 0,
+    total: chunks.length
+  });
+  await embedAll(embedder, texts, {
+    onProgress: (info) => {
+      onProgress?.({
+        phase: "embedding",
+        message: info.message,
+        current: info.current,
+        total: info.total
+      });
+    },
+    onBatch: async (embeddings, startIndex, count) => {
+      onProgress?.({
+        phase: "storing",
+        message: `Storing batch at offset ${startIndex}...`,
+        current: startIndex + count,
+        total: chunks.length
+      });
+      for (let i = 0; i < count; i += STORE_BATCH_SIZE) {
+        const end = Math.min(i + STORE_BATCH_SIZE, count);
+        const items = [];
+        for (let j = i; j < end; j++) {
+          items.push(chunkToVectorItem(chunks[startIndex + j], embeddings[j]));
+        }
+        await store.appendItems(items);
+      }
+    }
+  });
+}
+function buildEmbeddingText(chunk) {
+  const header = `File: ${chunk.filePath} (lines ${chunk.startLine}-${chunk.endLine})`;
+  return `${header}
+${chunk.content}`;
+}
+function groupChunkIdsByFile(chunks) {
+  const map = /* @__PURE__ */ new Map();
+  for (const c of chunks) {
+    const ids = map.get(c.filePath) ?? [];
+    ids.push(c.id);
+    map.set(c.filePath, ids);
+  }
+  return map;
+}
+function loadConfig(projectDir, dataDir) {
+  try {
+    const raw = fs8.readFileSync(codemapConfigFile(projectDir, dataDir), "utf-8");
+    return CodemapConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    return CodemapConfigSchema.parse({});
+  }
+}
+function saveCodemapConfig(projectDir, config, dataDir) {
+  const file = codemapConfigFile(projectDir, dataDir);
+  const dir = nodePath.dirname(file);
+  fs8.mkdirSync(dir, { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs8.writeFileSync(tmp, JSON.stringify(config, null, 2));
+  fs8.renameSync(tmp, file);
+}
+function saveStats(branchDir, stats) {
+  fs8.mkdirSync(branchDir, { recursive: true });
+  const file = nodePath.join(branchDir, "stats.json");
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs8.writeFileSync(tmp, JSON.stringify(stats, null, 2));
+  fs8.renameSync(tmp, file);
+}
+function loadStats(branchDir) {
+  try {
+    const file = nodePath.join(branchDir, "stats.json");
+    return JSON.parse(fs8.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function emptyStats() {
+  return {
+    totalFiles: 0,
+    totalChunks: 0,
+    staleFiles: 0,
+    indexSizeBytes: 0,
+    lastFullIndexMs: 0,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeScores(scores) {
+  if (scores.length === 0) return [];
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+  const range = max - min;
+  if (range === 0) return scores.map(() => 1);
+  return scores.map((s) => (s - min) / range);
+}
+function computePathBoost(filePath, query) {
+  const pathParts = filePath.toLowerCase().replace(/[^a-z0-9]/g, " ").split(/\s+/).filter(Boolean);
+  const queryTerms = query.toLowerCase().replace(/[^a-z0-9]/g, " ").split(/\s+/).filter(Boolean);
+  if (queryTerms.length === 0) return 0;
+  let matches = 0;
+  for (const qt of queryTerms) {
+    if (pathParts.some((pp) => pp.includes(qt))) matches++;
+  }
+  return matches / queryTerms.length;
+}
+function fuseResults(vectorResults, bm25Results, symbolResults, graphRanks, query, weights, topK) {
+  const candidates = /* @__PURE__ */ new Map();
+  const vScores = vectorResults.map((r) => r.score);
+  const vNorm = normalizeScores(vScores);
+  for (let i = 0; i < vectorResults.length; i++) {
+    const r = vectorResults[i];
+    candidates.set(r.id, {
+      id: r.id,
+      filePath: r.filePath,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      snippet: r.snippet,
+      vectorScore: vNorm[i],
+      fusedScore: 0
+    });
+  }
+  const bScores = bm25Results.map((r) => r.score);
+  const bNorm = normalizeScores(bScores);
+  for (let i = 0; i < bm25Results.length; i++) {
+    const r = bm25Results[i];
+    const existing = candidates.get(r.id);
+    if (existing) {
+      existing.bm25Score = bNorm[i];
+    } else {
+      candidates.set(r.id, {
+        id: r.id,
+        filePath: r.filePath,
+        startLine: 0,
+        endLine: 0,
+        snippet: "",
+        bm25Score: bNorm[i],
+        fusedScore: 0
+      });
+    }
+  }
+  for (const sym of symbolResults) {
+    const existing = candidates.get(sym.chunkId);
+    if (existing) {
+      existing.symbolScore = Math.max(existing.symbolScore ?? 0, sym.score);
+    }
+  }
+  for (const c of candidates.values()) {
+    c.pathBoost = computePathBoost(c.filePath, query);
+    if (graphRanks) {
+      c.graphRank = graphRanks.get(c.filePath) ?? 0;
+    }
+    c.fusedScore = weights.vector * (c.vectorScore ?? 0) + weights.bm25 * (c.bm25Score ?? 0) + weights.symbolBoost * (c.symbolScore ?? 0) + weights.pathBoost * (c.pathBoost ?? 0) + weights.graphRank * (c.graphRank ?? 0);
+  }
+  return Array.from(candidates.values()).sort((a, b) => b.fusedScore - a.fusedScore).slice(0, topK);
+}
+var TEST_PATTERNS = [/\btest[s]?\b/i, /__tests__/, /\.test\./, /\.spec\./];
+var DOC_EXTENSIONS = [".md", ".mdx", ".rst", ".txt"];
+function isTestFile(filePath) {
+  return TEST_PATTERNS.some((p) => p.test(filePath));
+}
+function isDocFile(filePath) {
+  return DOC_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+function loadCodemapConfig(projectDir, dataDir) {
+  try {
+    const raw = fs9.readFileSync(codemapConfigFile(projectDir, dataDir), "utf-8");
+    return CodemapConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    return CodemapConfigSchema.parse({});
+  }
+}
+async function searchCode(projectDir, query, options) {
+  const {
+    limit = 10,
+    threshold = 0,
+    pathPrefix,
+    includeTests = true,
+    includeDocs = true,
+    branch = "main",
+    dataDir
+  } = options ?? {};
+  const config = loadCodemapConfig(projectDir, dataDir);
+  const lanceDir = codemapLanceDir(projectDir, branch, dataDir);
+  const metadataDir = codemapMetadataDir(projectDir, branch, dataDir);
+  const embedder = await createEmbedder(config.embedding);
+  const queryVector = await embedOne(embedder, query);
+  const store = new CodemapStore(lanceDir, embedder.dimensions);
+  await store.initialize();
+  try {
+    const hybridConfig = config.hybrid;
+    if (hybridConfig.enabled) {
+      return await hybridSearch(
+        store,
+        metadataDir,
+        queryVector,
+        query,
+        hybridConfig.weights,
+        hybridConfig.vectorK,
+        hybridConfig.bm25K,
+        limit,
+        threshold,
+        pathPrefix,
+        includeTests,
+        includeDocs
+      );
+    }
+    return await vectorOnlySearch(
+      store,
+      queryVector,
+      limit,
+      threshold,
+      pathPrefix,
+      includeTests,
+      includeDocs
+    );
+  } finally {
+    await store.close();
+  }
+}
+async function hybridSearch(store, metadataDir, queryVector, query, weights, vectorK, bm25K, limit, threshold, pathPrefix, includeTests, includeDocs) {
+  const vectorResults = await store.query(queryVector, vectorK);
+  const bm25Index = loadBM25Index(metadataDir);
+  const bm25Results = bm25Index ? queryBM25(bm25Index, query, bm25K) : [];
+  const symbolIndex = loadSymbolIndex(metadataDir);
+  const symbolMatches = searchSymbols(symbolIndex, query, 50);
+  const symbolResults = symbolMatches.map((m) => ({
+    chunkId: m.entry.chunkId,
+    filePath: m.entry.filePath,
+    score: m.score
+  }));
+  let graphRanks = null;
+  if (weights.graphRank > 0) {
+    graphRanks = loadGraphRanks(metadataDir);
+  }
+  const fused = fuseResults(
+    vectorResults,
+    bm25Results,
+    symbolResults,
+    graphRanks,
+    query,
+    weights,
+    Math.max(limit * 3, 80)
+  );
+  return applyFilters(fused, limit, threshold, pathPrefix, includeTests, includeDocs);
+}
+async function vectorOnlySearch(store, queryVector, limit, threshold, pathPrefix, includeTests, includeDocs) {
+  const candidateK = Math.min(limit * 3, 80);
+  const results = await store.query(queryVector, candidateK);
+  const fused = results.map((r) => ({
+    ...r,
+    vectorScore: r.score,
+    fusedScore: r.score
+  }));
+  return applyFilters(fused, limit, threshold, pathPrefix, includeTests, includeDocs);
+}
+function applyFilters(candidates, limit, threshold, pathPrefix, includeTests, includeDocs) {
+  let filtered = candidates;
+  if (threshold > 0) {
+    filtered = filtered.filter((c) => c.fusedScore >= threshold);
+  }
+  if (pathPrefix) {
+    filtered = filtered.filter((c) => c.filePath.startsWith(pathPrefix));
+  }
+  if (!includeTests) {
+    filtered = filtered.filter((c) => !isTestFile(c.filePath));
+  }
+  if (!includeDocs) {
+    filtered = filtered.filter((c) => !isDocFile(c.filePath));
+  }
+  return filtered.slice(0, limit).map((c) => ({
+    id: c.id,
+    filePath: c.filePath,
+    startLine: c.startLine,
+    endLine: c.endLine,
+    snippet: c.snippet,
+    score: c.fusedScore,
+    vectorScore: c.vectorScore,
+    bm25Score: c.bm25Score,
+    symbolScore: c.symbolScore
+  }));
+}
+function loadGraphRanks(metadataDir) {
+  try {
+    const file = path8.join(metadataDir, "depgraph", "pagerank.json");
+    const raw = JSON.parse(fs9.readFileSync(file, "utf-8"));
+    return new Map(Object.entries(raw));
+  } catch {
+    return null;
+  }
+}
+var DEBOUNCE_MS = 300;
+var RECONCILE_INTERVAL_MS = 6e4;
+var RECOVERY_COOLDOWN_MS = 5 * 60 * 1e3;
+var CORRUPTION_PATTERNS = [
+  /Not found.*lance/i,
+  /LanceError/i,
+  /corrupted/i,
+  /panic/i
+];
+var CodemapWatcher = class {
+  constructor(projectDir, options = {}) {
+    this.projectDir = projectDir;
+    this.options = options;
+    this.debounceMs = options.debounceMs ?? DEBOUNCE_MS;
+    this.reconcileIntervalMs = options.reconcileIntervalMs ?? RECONCILE_INTERVAL_MS;
+  }
+  watcher = null;
+  pendingPaths = /* @__PURE__ */ new Set();
+  debounceTimer = null;
+  reconcileTimer = null;
+  processing = false;
+  bufferedPaths = /* @__PURE__ */ new Set();
+  lastRecoveryAt = 0;
+  _isRunning = false;
+  _totalEventsProcessed = 0;
+  _lastFlushAt = null;
+  _recovering = false;
+  _recoveryPromise = null;
+  _denyPatterns = [];
+  debounceMs;
+  reconcileIntervalMs;
+  get isRunning() {
+    return this._isRunning;
+  }
+  get queueDepth() {
+    return this.pendingPaths.size + this.bufferedPaths.size;
+  }
+  get totalEventsProcessed() {
+    return this._totalEventsProcessed;
+  }
+  get lastFlushAt() {
+    return this._lastFlushAt;
+  }
+  /**
+   * Start watching for file changes.
+   */
+  start() {
+    if (this._isRunning) return;
+    this.reloadDenyPatterns();
+    this.watcher = fs10.watch(this.projectDir, { recursive: true }, (_event, filename) => {
+      if (!filename) return;
+      const relPath = filename.replace(/\\/g, "/");
+      if (this._denyPatterns.some((p) => matchesDenyPattern(relPath, p))) return;
+      if (relPath.split("/").some((part) => part.startsWith("."))) return;
+      this.enqueue(relPath);
+    });
+    this.reconcileTimer = setInterval(() => {
+      this.reconcile();
+    }, this.reconcileIntervalMs);
+    this._isRunning = true;
+    console.error(`[codemap-engine] Watcher started for ${this.projectDir}`);
+  }
+  /**
+   * Stop watching and flush any remaining events.
+   */
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.reconcileTimer) {
+      clearInterval(this.reconcileTimer);
+      this.reconcileTimer = null;
+    }
+    if (this._recoveryPromise) {
+      await this._recoveryPromise;
+    }
+    for (const p of this.bufferedPaths) this.pendingPaths.add(p);
+    this.bufferedPaths.clear();
+    if (this.pendingPaths.size > 0) {
+      await this.flush();
+    }
+    console.error(`[codemap-engine] Watcher stopped for ${this.projectDir}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  enqueue(relPath) {
+    if (this.processing || this._recovering) {
+      this.bufferedPaths.add(relPath);
+      return;
+    }
+    this.pendingPaths.add(relPath);
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flush().catch((err) => {
+        console.error("[codemap-engine] Flush error:", err);
+        this.handleError(err);
+      });
+    }, this.debounceMs);
+  }
+  async flush() {
+    if (this.processing || this._recovering) return;
+    if (this.pendingPaths.size === 0) return;
+    this.processing = true;
+    this.reloadDenyPatterns();
+    const paths = [...this.pendingPaths];
+    this.pendingPaths.clear();
+    try {
+      await runIncrementalPipeline(this.projectDir, paths, {
+        branch: this.options.branch ?? "main",
+        dataDir: this.options.dataDir
+      });
+      this._totalEventsProcessed += paths.length;
+      this._lastFlushAt = /* @__PURE__ */ new Date();
+    } catch (err) {
+      console.error("[codemap-engine] Incremental pipeline error:", err);
+      this.handleError(err);
+    } finally {
+      this.processing = false;
+    }
+    if (this.bufferedPaths.size > 0) {
+      for (const p of this.bufferedPaths) {
+        this.pendingPaths.add(p);
+      }
+      this.bufferedPaths.clear();
+      this.scheduleFlush();
+    }
+  }
+  async reconcile() {
+    if (this.processing || this._recovering) return;
+    this.processing = true;
+    this.reloadDenyPatterns();
+    try {
+      await runIncrementalPipeline(this.projectDir, void 0, {
+        branch: this.options.branch ?? "main",
+        dataDir: this.options.dataDir
+      });
+    } catch (err) {
+      console.error("[codemap-engine] Reconciliation error:", err);
+    } finally {
+      this.processing = false;
+    }
+    if (this.bufferedPaths.size > 0) {
+      for (const p of this.bufferedPaths) {
+        this.pendingPaths.add(p);
+      }
+      this.bufferedPaths.clear();
+      this.scheduleFlush();
+    }
+  }
+  handleError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (CORRUPTION_PATTERNS.some((p) => p.test(msg))) {
+      const now = Date.now();
+      if (now - this.lastRecoveryAt < RECOVERY_COOLDOWN_MS) {
+        console.error("[codemap-engine] Corruption detected but in cooldown, skipping recovery");
+        return;
+      }
+      if (this._recovering) return;
+      this.lastRecoveryAt = now;
+      this._recovering = true;
+      console.error("[codemap-engine] Corruption detected, triggering full re-index");
+      this._recoveryPromise = runInitPipeline(this.projectDir, void 0, {
+        branch: this.options.branch ?? "main",
+        dataDir: this.options.dataDir
+      }).then(() => {
+      }).catch((e) => {
+        console.error("[codemap-engine] Recovery re-index failed:", e);
+      }).finally(() => {
+        this._recovering = false;
+        this._recoveryPromise = null;
+        if (this.bufferedPaths.size > 0) {
+          for (const p of this.bufferedPaths) {
+            this.pendingPaths.add(p);
+          }
+          this.bufferedPaths.clear();
+          if (this._isRunning) this.scheduleFlush();
+        }
+      });
+    }
+  }
+  reloadDenyPatterns() {
+    const config = this.loadConfig();
+    const ignorePatterns = loadCodemapIgnore(this.projectDir);
+    this._denyPatterns = [...config.deny, ...ignorePatterns];
+  }
+  loadConfig() {
+    try {
+      const raw = fs10.readFileSync(codemapConfigFile(this.projectDir, this.options.dataDir), "utf-8");
+      return CodemapConfigSchema.parse(JSON.parse(raw));
+    } catch {
+      return CodemapConfigSchema.parse({});
+    }
+  }
+};
+
+// src/config.ts
+import fs11 from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+var DEFAULT_DATA_DIR = join2(homedir2(), ".codemap");
+function getDataDir2() {
+  return process.env["CODEMAP_DATA_DIR"] || DEFAULT_DATA_DIR;
+}
+function globalConfigFile() {
+  return join2(getDataDir2(), "config.json");
+}
+function projectConfigFile(projectDir) {
+  return join2(resolve2(projectDir), ".codemap.json");
+}
+function loadCliConfig(projectDir) {
+  let global = {};
+  let project = {};
+  try {
+    global = JSON.parse(fs11.readFileSync(globalConfigFile(), "utf-8"));
+  } catch {
+  }
+  try {
+    project = JSON.parse(fs11.readFileSync(projectConfigFile(projectDir), "utf-8"));
+  } catch {
+  }
+  return {
+    embedding: { ...global.embedding, ...project.embedding },
+    ollama: { ...global.ollama, ...project.ollama }
+  };
+}
+function saveCliConfig(config) {
+  const dir = getDataDir2();
+  fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(globalConfigFile(), JSON.stringify(config, null, 2) + "\n");
+}
+function bridgeEnvVars(config) {
+  if (config.embedding?.apiKey && config.embedding.provider === "openai") {
+    process.env["OPENAI_API_KEY"] ??= config.embedding.apiKey;
+  }
+  if (config.embedding?.apiKey && config.embedding.provider === "ulpi") {
+    process.env["ULPI_API_KEY"] ??= config.embedding.apiKey;
+  }
+  if (config.ollama?.host) {
+    process.env["OLLAMA_HOST"] ??= config.ollama.host;
+  }
+  if (config.embedding?.baseUrl) {
+    process.env["ULPI_EMBED_URL"] ??= config.embedding.baseUrl;
+  }
+}
+function resolveCodemapConfig(cliConfig) {
+  if (!cliConfig.embedding?.provider || !cliConfig.embedding.model || !cliConfig.embedding.dimensions) {
+    throw new Error(
+      "No embedding configuration found. Run `codemap init` to set up your provider and model."
+    );
+  }
+  return CodemapConfigSchema.parse({
+    embedding: {
+      provider: cliConfig.embedding.provider,
+      model: cliConfig.embedding.model,
+      dimensions: cliConfig.embedding.dimensions,
+      baseUrl: cliConfig.embedding.baseUrl
+    }
+  });
+}
+
+// src/commands/search.ts
+function registerSearch(program2) {
+  program2.command("search <query>").description("Search code using hybrid vector + BM25").option("-l, --limit <n>", "Max results", "10").option("--json", "Output as JSON").action(async (query, opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    bridgeEnvVars(config);
+    const branch = getCurrentBranch(projectDir);
+    const limit = parseInt(opts.limit, 10);
+    const results = await searchCode(projectDir, query, {
+      limit,
+      branch,
+      dataDir: getDataDir2()
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+    if (results.length === 0) {
+      console.log(chalk.yellow("No results found."));
+      return;
+    }
+    for (const r of results) {
+      const score = Math.round(r.score * 1e3) / 1e3;
+      console.log(chalk.cyan(`${r.filePath}:${r.startLine}`) + chalk.dim(` (score: ${score})`));
+      const lines = r.snippet.split("\n").slice(0, 5);
+      for (const line of lines) {
+        console.log(chalk.dim("  ") + line);
+      }
+      console.log();
+    }
+  });
+}
+
+// src/commands/symbols.ts
+import chalk2 from "chalk";
+function registerSymbols(program2) {
+  program2.command("symbols <query>").description("Find functions, classes, and types by name").option("-l, --limit <n>", "Max results", "20").option("--json", "Output as JSON").action(async (query, opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const metaDir = codemapMetadataDir(projectDir, branch, getDataDir2());
+    const symbolIndex = loadSymbolIndex(metaDir);
+    const limit = parseInt(opts.limit, 10);
+    const matches = searchSymbols(symbolIndex, query, limit);
+    if (opts.json) {
+      console.log(JSON.stringify(matches.map((m) => ({
+        name: m.entry.name,
+        type: m.entry.symbolType,
+        file: m.entry.filePath,
+        line: m.entry.startLine,
+        score: Math.round(m.score * 1e3) / 1e3
+      })), null, 2));
+      return;
+    }
+    if (matches.length === 0) {
+      console.log(chalk2.yellow("No symbols found."));
+      return;
+    }
+    console.log(
+      chalk2.bold("Name".padEnd(40)) + chalk2.bold("Type".padEnd(12)) + chalk2.bold("File".padEnd(50)) + chalk2.bold("Line")
+    );
+    console.log(chalk2.dim("-".repeat(110)));
+    for (const m of matches) {
+      console.log(
+        chalk2.cyan(m.entry.name.padEnd(40)) + chalk2.dim(m.entry.symbolType.padEnd(12)) + m.entry.filePath.padEnd(50) + String(m.entry.startLine)
+      );
+    }
+  });
+}
+
+// src/commands/index-cmd.ts
+import chalk4 from "chalk";
+
+// src/commands/init.ts
+import chalk3 from "chalk";
+import fs12 from "fs";
+import path9 from "path";
+import readline from "readline";
+var DEFAULT_CODEMAPIGNORE = `# ============================================================
+# .codemapignore \u2014 files excluded from codemap indexing
+# Syntax: same as .gitignore (glob patterns, # comments)
+# Note: .gitignore is already respected via git ls-files
+# ============================================================
+
+# -----------------------------------------------------------
+# Build output
+# -----------------------------------------------------------
+dist/
+build/
+out/
+*.tsbuildinfo
+
+# -----------------------------------------------------------
+# Dependencies
+# -----------------------------------------------------------
+node_modules/
+vendor/
+.pnp.*
+
+# -----------------------------------------------------------
+# Lock files (large, low signal)
+# -----------------------------------------------------------
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+composer.lock
+Gemfile.lock
+Pipfile.lock
+poetry.lock
+go.sum
+Cargo.lock
+
+# -----------------------------------------------------------
+# Static assets
+# -----------------------------------------------------------
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.svg
+*.ico
+*.webp
+*.avif
+*.bmp
+*.tiff
+*.woff
+*.woff2
+*.ttf
+*.otf
+*.eot
+*.mp3
+*.mp4
+*.wav
+*.webm
+*.pdf
+
+# -----------------------------------------------------------
+# Generated / minified
+# -----------------------------------------------------------
+*.min.js
+*.min.css
+*.map
+*.bundle.js
+*.chunk.js
+
+# -----------------------------------------------------------
+# Test artifacts
+# -----------------------------------------------------------
+__snapshots__/
+*.snap
+coverage/
+.nyc_output/
+lcov.info
+
+# -----------------------------------------------------------
+# Cache
+# -----------------------------------------------------------
+.cache/
+*.cache
+.eslintcache
+.stylelintcache
+.parcel-cache/
+
+# -----------------------------------------------------------
+# Environment & secrets
+# -----------------------------------------------------------
+.env
+.env.*
+
+# -----------------------------------------------------------
+# AI agent config (prompts, not code)
+# -----------------------------------------------------------
+.claude/
+.codex/
+.kiro/
+.gemini/
+.factory/
+.opencode/
+AGENTS.md
+CLAUDE.md
+
+# -----------------------------------------------------------
+# OS / editor
+# -----------------------------------------------------------
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/settings.json
+*.swp
+*.swo
+
+# -----------------------------------------------------------
+# Monorepo / project config (low signal)
+# -----------------------------------------------------------
+.editorconfig
+.npmrc
+.nvmrc
+.node-version
+turbo.json
+nx.json
+lerna.json
+
+# -----------------------------------------------------------
+# Next.js
+# -----------------------------------------------------------
+.next/
+_buildManifest.js
+_ssgManifest.js
+
+# -----------------------------------------------------------
+# Nuxt / Vue
+# -----------------------------------------------------------
+.nuxt/
+.output/
+
+# -----------------------------------------------------------
+# Svelte
+# -----------------------------------------------------------
+.svelte-kit/
+
+# -----------------------------------------------------------
+# Vite / Turbopack
+# -----------------------------------------------------------
+.turbo/
+
+# -----------------------------------------------------------
+# React Native / Expo
+# -----------------------------------------------------------
+ios/Pods/
+ios/build/
+android/.gradle/
+android/build/
+android/app/build/
+.expo/
+*.jsbundle
+*.hbc
+
+# -----------------------------------------------------------
+# Laravel / PHP
+# -----------------------------------------------------------
+bootstrap/cache/
+storage/framework/
+storage/logs/
+public/build/
+public/hot
+public/storage
+public/mix-manifest.json
+_ide_helper*.php
+.phpstorm.meta.php
+.php-cs-fixer.cache
+
+# -----------------------------------------------------------
+# Magento 2
+# -----------------------------------------------------------
+generated/
+pub/static/
+var/cache/
+var/page_cache/
+var/view_preprocessed/
+var/generation/
+var/di/
+var/log/
+var/report/
+setup/src/
+lib/internal/
+dev/tests/
+*.less.css
+`;
+function writeCodemapIgnore(projectDir, force = false) {
+  const ignorePath = path9.join(projectDir, ".codemapignore");
+  if (!force && fs12.existsSync(ignorePath)) return false;
+  fs12.writeFileSync(ignorePath, DEFAULT_CODEMAPIGNORE);
+  return true;
+}
+function registerInit(program2) {
+  program2.command("init").description("Interactive first-time setup for codemap").option("--provider <provider>", "Embedding provider (ollama, openai, or ulpi)").option("--force", "Reconfigure even if already set up").action(async (opts) => {
+    console.log(chalk3.bold("Codemap Setup"));
+    console.log(chalk3.dim("-".repeat(40)));
+    console.log();
+    const config = loadCliConfig(program2.opts().cwd || process.cwd());
+    if (!opts.force && config.embedding?.provider && config.embedding.model && config.embedding.dimensions) {
+      console.log("Existing configuration found:");
+      console.log(`  Provider:   ${chalk3.cyan(config.embedding.provider)}`);
+      console.log(`  Model:      ${chalk3.cyan(config.embedding.model)}`);
+      console.log(`  Dimensions: ${chalk3.cyan(String(config.embedding.dimensions))}`);
+      if (config.embedding.apiKey) {
+        const masked = config.embedding.apiKey.slice(0, 8) + "...";
+        console.log(`  API key:    ${chalk3.cyan(masked)}`);
+      }
+      console.log();
+      const answer = await ask("Reconfigure? (y/N): ");
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk3.dim("Keeping existing config. Use --force to skip this prompt."));
+        return;
+      }
+      console.log();
+    }
+    let provider = opts.provider;
+    if (!provider) {
+      console.log("Available embedding providers:");
+      console.log(`  ${chalk3.cyan("1")} ulpi     \u2014 managed cloud service by ULPI`);
+      console.log(`  ${chalk3.cyan("2")} ollama   \u2014 free, local, requires Ollama running`);
+      console.log(`  ${chalk3.cyan("3")} openai   \u2014 cloud, requires API key`);
+      console.log();
+      const choice = await ask("Choose provider (1, 2, or 3): ");
+      provider = choice === "1" ? "ulpi" : choice === "2" ? "ollama" : choice === "3" ? "openai" : choice;
+    }
+    if (provider !== "ollama" && provider !== "openai" && provider !== "ulpi") {
+      console.error(chalk3.red(`Unknown provider: ${provider}. Use "ollama", "openai", or "ulpi".`));
+      process.exit(1);
+    }
+    config.embedding = config.embedding ?? {};
+    config.embedding.provider = provider;
+    if (provider === "ulpi") {
+      config.embedding.model = "code";
+      config.embedding.dimensions = 1024;
+      config.embedding.baseUrl = ULPI_API_BASE;
+      console.log();
+      console.log(chalk3.dim('ULPI Cloud uses the "code" embedding model (1024 dimensions).'));
+      console.log();
+      const hasAccount = await ask("Do you have a ULPI account? (y/n): ");
+      if (hasAccount.toLowerCase() === "y") {
+        const apiKey = await ask("API key: ");
+        if (apiKey) {
+          config.embedding.apiKey = apiKey;
+        } else {
+          console.log(chalk3.yellow("No API key provided. Set it later with:"));
+          console.log(chalk3.dim("  codemap config set embedding.apiKey <key>"));
+        }
+      } else {
+        console.log();
+        console.log(chalk3.bold("Create your ULPI account"));
+        console.log();
+        const name = await ask("Name: ");
+        const email = await ask("Email: ");
+        const password = await askSecret("Password: ");
+        const passwordConfirm = await askSecret("Confirm password: ");
+        if (password !== passwordConfirm) {
+          console.error(chalk3.red("Passwords do not match."));
+          process.exit(1);
+        }
+        try {
+          console.log();
+          console.log(chalk3.dim("Registering..."));
+          const token = await ulpiRegister(name, email, password);
+          console.log(chalk3.green("Account created."));
+          console.log(chalk3.dim("Creating API key..."));
+          const apiKey = await ulpiCreateKey(token);
+          config.embedding.apiKey = apiKey;
+          console.log(chalk3.green("API key: ") + chalk3.cyan(apiKey));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(chalk3.red(`Registration failed: ${msg}`));
+          console.log();
+          console.log(chalk3.yellow("You can set the API key manually later:"));
+          console.log(chalk3.dim("  codemap config set embedding.apiKey <key>"));
+        }
+      }
+    } else if (provider === "ollama") {
+      console.log();
+      console.log("Available Ollama embedding models:");
+      console.log(`  ${chalk3.cyan("1")} nomic-embed-text   \u2014 768 dimensions`);
+      console.log(`  ${chalk3.cyan("2")} mxbai-embed-large  \u2014 1024 dimensions`);
+      console.log(`  ${chalk3.cyan("3")} all-minilm          \u2014 384 dimensions`);
+      console.log();
+      const modelChoice = await ask("Choose model (1, 2, or 3): ");
+      if (modelChoice === "2") {
+        config.embedding.model = "mxbai-embed-large";
+        config.embedding.dimensions = 1024;
+      } else if (modelChoice === "3") {
+        config.embedding.model = "all-minilm";
+        config.embedding.dimensions = 384;
+      } else {
+        config.embedding.model = "nomic-embed-text";
+        config.embedding.dimensions = 768;
+      }
+      console.log();
+      const host = await ask("Ollama host (leave empty for http://localhost:11434): ");
+      if (host) {
+        config.ollama = { host };
+      }
+      console.log();
+      console.log(chalk3.dim(`Make sure Ollama is running and has ${config.embedding.model}:`));
+      console.log(chalk3.dim(`  ollama pull ${config.embedding.model}`));
+    } else {
+      console.log();
+      console.log("Available OpenAI embedding models:");
+      console.log(`  ${chalk3.cyan("1")} text-embedding-3-small  \u2014 1536 dimensions`);
+      console.log(`  ${chalk3.cyan("2")} text-embedding-3-large  \u2014 3072 dimensions`);
+      console.log();
+      const modelChoice = await ask("Choose model (1 or 2): ");
+      if (modelChoice === "2") {
+        config.embedding.model = "text-embedding-3-large";
+        config.embedding.dimensions = 3072;
+      } else {
+        config.embedding.model = "text-embedding-3-small";
+        config.embedding.dimensions = 1536;
+      }
+      console.log();
+      const apiKey = await ask("OpenAI API key: ");
+      if (apiKey) {
+        config.embedding.apiKey = apiKey;
+      } else {
+        console.log(chalk3.yellow("No API key provided. Set it later with:"));
+        console.log(chalk3.dim("  codemap config set embedding.apiKey sk-..."));
+      }
+    }
+    saveCliConfig(config);
+    const projectDir = program2.opts().cwd || process.cwd();
+    const wroteIgnore = writeCodemapIgnore(projectDir);
+    console.log();
+    console.log(chalk3.green("Config saved to ") + chalk3.cyan(getDataDir2() + "/config.json"));
+    if (wroteIgnore) {
+      console.log(chalk3.green("Created ") + chalk3.cyan(".codemapignore") + chalk3.green(" with default patterns"));
+    }
+    console.log();
+    console.log("Next steps:");
+    console.log(`  ${chalk3.cyan("codemap index")}    Index your project`);
+    console.log(`  ${chalk3.cyan("codemap search")}   Search your code`);
+    console.log(`  ${chalk3.cyan("codemap serve")}    Start MCP server`);
+  });
+}
+var ULPI_API_BASE = "https://codemap.ulpi.io";
+var ULPI_AUTH_BASE = "https://codemap.ulpi.io/api/v1";
+function ask(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve3(answer.trim());
+    });
+  });
+}
+function askSecret(prompt) {
+  return new Promise((resolve3) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY && stdin.setRawMode) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    let input = "";
+    const onData = (ch) => {
+      const c = ch.toString("utf-8");
+      if (c === "\n" || c === "\r" || c === "") {
+        if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false);
+        stdin.removeListener("data", onData);
+        stdin.pause();
+        process.stdout.write("\n");
+        resolve3(input.trim());
+      } else if (c === "") {
+        if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false);
+        stdin.removeListener("data", onData);
+        stdin.pause();
+        process.exit(1);
+      } else if (c === "\x7F" || c === "\b") {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else if (c.charCodeAt(0) >= 32) {
+        input += c;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function ulpiRegister(name, email, password) {
+  const res = await fetch(`${ULPI_AUTH_BASE}/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Accept": "application/json" },
+    body: JSON.stringify({ name, email, password, password_confirmation: password })
+  });
+  const data = await res.json();
+  if (!res.ok || !data.token) {
+    if (data.errors) {
+      const msgs = Object.values(data.errors).flat();
+      throw new Error(msgs.join(", "));
+    }
+    throw new Error(data.message ?? `HTTP ${res.status}`);
+  }
+  return data.token;
+}
+async function ulpiCreateKey(token) {
+  const res = await fetch(`${ULPI_AUTH_BASE}/keys`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Authorization": `Bearer ${token}`
+    },
+    body: JSON.stringify({ name: "codemap-cli" })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.message ?? `HTTP ${res.status}`);
+  }
+  const key = data.plain_text_key ?? data.key;
+  if (!key) {
+    throw new Error("No API key in response");
+  }
+  return key;
+}
+
+// src/commands/index-cmd.ts
+function registerIndex(program2) {
+  program2.command("index").description("Index the current project for code search").option("--full", "Force full re-index (ignore incremental state)").action(async (_opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const cliConfig = loadCliConfig(projectDir);
+    bridgeEnvVars(cliConfig);
+    const config = resolveCodemapConfig(cliConfig);
+    const branch = getCurrentBranch(projectDir);
+    if (writeCodemapIgnore(projectDir)) {
+      console.log(chalk4.green("Created ") + chalk4.cyan(".codemapignore") + chalk4.green(" with default patterns"));
+      console.log();
+    }
+    console.log(chalk4.bold("Indexing ") + chalk4.cyan(projectDir));
+    console.log(chalk4.dim(`Branch: ${branch} | Provider: ${config.embedding.provider} | Model: ${config.embedding.model}`));
+    console.log();
+    const stats = await runInitPipeline(projectDir, config, {
+      branch,
+      dataDir: getDataDir2(),
+      onProgress: (progress) => {
+        const pct = progress.total ? ` (${progress.current ?? 0}/${progress.total})` : "";
+        console.log(chalk4.dim(`[${progress.phase}]`) + ` ${progress.message}${pct}`);
+      }
+    });
+    console.log();
+    console.log(chalk4.green("Index complete:"));
+    console.log(`  Files:  ${stats.totalFiles}`);
+    console.log(`  Chunks: ${stats.totalChunks}`);
+    console.log(`  Time:   ${stats.lastFullIndexMs}ms`);
+  });
+}
+
+// src/commands/watch.ts
+import chalk5 from "chalk";
+function registerWatch(program2) {
+  program2.command("watch").description("Watch for file changes and update index in real-time").option("--debounce <ms>", "Debounce interval in milliseconds", "300").action(async (opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    bridgeEnvVars(config);
+    const branch = getCurrentBranch(projectDir);
+    const debounceMs = parseInt(opts.debounce, 10);
+    console.log(chalk5.bold("Watching ") + chalk5.cyan(projectDir));
+    console.log(chalk5.dim(`Branch: ${branch} | Press Ctrl+C to stop`));
+    console.log();
+    const watcher = new CodemapWatcher(projectDir, {
+      branch,
+      debounceMs,
+      dataDir: getDataDir2()
+    });
+    watcher.start();
+    const cleanup = async () => {
+      console.log(chalk5.dim("\nStopping watcher..."));
+      await watcher.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    setInterval(() => {
+      const depth = watcher.queueDepth;
+      const total = watcher.totalEventsProcessed;
+      if (depth > 0) {
+        console.log(chalk5.dim(`Queue: ${depth} | Processed: ${total}`));
+      }
+    }, 5e3);
+  });
+}
+
+// src/commands/status.ts
+import chalk6 from "chalk";
+import fs13 from "fs";
+function registerStatus(program2) {
+  program2.command("status").description("Show index statistics for the current project").option("--json", "Output as JSON").action(async (opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const statsFile = codemapStatsFile(projectDir, branch, getDataDir2());
+    let stats = null;
+    try {
+      stats = JSON.parse(fs13.readFileSync(statsFile, "utf-8"));
+    } catch {
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ projectDir, branch, stats }, null, 2));
+      return;
+    }
+    console.log(chalk6.bold("Codemap Status"));
+    console.log(chalk6.dim("-".repeat(40)));
+    console.log(`Project:  ${chalk6.cyan(projectDir)}`);
+    console.log(`Branch:   ${branch}`);
+    console.log(`Data dir: ${getDataDir2()}`);
+    console.log();
+    if (!stats) {
+      console.log(chalk6.yellow("No index found. Run `codemap index` first."));
+      return;
+    }
+    console.log(`Files:       ${stats.totalFiles}`);
+    console.log(`Chunks:      ${stats.totalChunks}`);
+    console.log(`Stale files: ${stats.staleFiles}`);
+    console.log(`Index size:  ${formatBytes(stats.indexSizeBytes)}`);
+    console.log(`Last index:  ${stats.lastFullIndexMs}ms`);
+    console.log(`Updated:     ${stats.lastUpdated}`);
+  });
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/commands/serve.ts
+import fs14 from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z14 } from "zod";
+
+// ../../packages/intelligence/depgraph-engine/dist/index.js
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+function getIncomingEdges(graph, filePath) {
+  return graph.edges.filter((e) => e.target === filePath);
+}
+function getOutgoingEdges(graph, filePath) {
+  return graph.edges.filter((e) => e.source === filePath);
+}
+function loadGraph(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_DAMPING = 0.85;
+var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_CONVERGENCE = 1e-6;
+var ACTIVE_FILE_BOOST = 100;
+var MENTIONED_FILE_BOOST = 5;
+var MENTIONED_IDENTIFIER_BOOST = 10;
+function computePageRank(graph, config, personalization) {
+  const d2 = config?.dampingFactor ?? DEFAULT_DAMPING;
+  const maxIter = config?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const threshold = config?.convergenceThreshold ?? DEFAULT_CONVERGENCE;
+  const files = Object.keys(graph.nodes);
+  const N = files.length;
+  if (N === 0) {
+    return { ranks: {}, iterations: 0, converged: true, dampingFactor: d2 };
+  }
+  const outNeighbors = /* @__PURE__ */ new Map();
+  const outDegree = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    outNeighbors.set(file, []);
+    outDegree.set(file, 0);
+  }
+  for (const edge of graph.edges) {
+    const neighbors = outNeighbors.get(edge.source);
+    if (neighbors) {
+      neighbors.push(edge.target);
+      outDegree.set(edge.source, (outDegree.get(edge.source) ?? 0) + 1);
+    }
+  }
+  const inNeighbors = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    inNeighbors.set(file, []);
+  }
+  for (const edge of graph.edges) {
+    const incoming = inNeighbors.get(edge.target);
+    if (incoming) {
+      incoming.push(edge.source);
+    }
+  }
+  const personalVector = buildPersonalizationVector(files, graph, personalization);
+  let ranks = /* @__PURE__ */ new Map();
+  const initial = 1 / N;
+  for (const file of files) {
+    ranks.set(file, initial);
+  }
+  let converged = false;
+  let iterations = 0;
+  for (let iter = 0; iter < maxIter; iter++) {
+    iterations = iter + 1;
+    const newRanks = /* @__PURE__ */ new Map();
+    let danglingSum = 0;
+    for (const file of files) {
+      if ((outDegree.get(file) ?? 0) === 0) {
+        danglingSum += ranks.get(file) ?? 0;
+      }
+    }
+    const personalTotal = personalVector ? Array.from(personalVector.values()).reduce((a, b) => a + b, 0) : 0;
+    for (const file of files) {
+      let linkSum = 0;
+      const incoming = inNeighbors.get(file) ?? [];
+      for (const src of incoming) {
+        const srcRank = ranks.get(src) ?? 0;
+        const srcDegree = outDegree.get(src) ?? 1;
+        linkSum += srcRank / srcDegree;
+      }
+      const danglingContrib = danglingSum / N;
+      let teleport;
+      if (personalVector && personalTotal > 0) {
+        teleport = (personalVector.get(file) ?? 0) / personalTotal;
+      } else {
+        teleport = 1 / N;
+      }
+      const rank = (1 - d2) * teleport + d2 * (linkSum + danglingContrib);
+      newRanks.set(file, rank);
+    }
+    let diff = 0;
+    for (const file of files) {
+      diff += Math.abs((newRanks.get(file) ?? 0) - (ranks.get(file) ?? 0));
+    }
+    ranks = newRanks;
+    if (diff < threshold) {
+      converged = true;
+      break;
+    }
+  }
+  const result = {};
+  for (const [file, rank] of ranks) {
+    result[file] = rank;
+  }
+  return {
+    ranks: result,
+    iterations,
+    converged,
+    dampingFactor: d2
+  };
+}
+function savePageRank(result, filePath) {
+  mkdirSync2(dirname2(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(result, null, 2), "utf-8");
+}
+function loadPageRank(filePath) {
+  try {
+    const raw = readFileSync2(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function buildPersonalizationVector(files, graph, personalization) {
+  if (!personalization) return null;
+  const {
+    activeFiles = [],
+    mentionedFiles = [],
+    mentionedIdentifiers = []
+  } = personalization;
+  if (activeFiles.length === 0 && mentionedFiles.length === 0 && mentionedIdentifiers.length === 0) {
+    return null;
+  }
+  const vector = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    vector.set(file, 1);
+  }
+  const activeSet = new Set(activeFiles);
+  for (const file of files) {
+    if (activeSet.has(file)) {
+      vector.set(file, (vector.get(file) ?? 0) + ACTIVE_FILE_BOOST);
+    }
+  }
+  const mentionedSet = new Set(mentionedFiles);
+  for (const file of files) {
+    if (mentionedSet.has(file)) {
+      vector.set(file, (vector.get(file) ?? 0) + MENTIONED_FILE_BOOST);
+    }
+  }
+  if (mentionedIdentifiers.length > 0) {
+    const identSet = new Set(mentionedIdentifiers);
+    for (const edge of graph.edges) {
+      for (const sym of edge.symbols) {
+        if (identSet.has(sym)) {
+          vector.set(
+            edge.target,
+            (vector.get(edge.target) ?? 0) + MENTIONED_IDENTIFIER_BOOST
+          );
+        }
+      }
+    }
+  }
+  return vector;
+}
+function detectCycles(graph) {
+  const files = Object.keys(graph.nodes);
+  const adj = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    adj.set(file, []);
+  }
+  for (const edge of graph.edges) {
+    const neighbors = adj.get(edge.source);
+    if (neighbors) {
+      neighbors.push(edge.target);
+    }
+  }
+  let index = 0;
+  const nodeIndex = /* @__PURE__ */ new Map();
+  const nodeLowlink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const sccs = [];
+  function strongConnect(v) {
+    nodeIndex.set(v, index);
+    nodeLowlink.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of adj.get(v) ?? []) {
+      if (!nodeIndex.has(w)) {
+        strongConnect(w);
+        nodeLowlink.set(v, Math.min(nodeLowlink.get(v), nodeLowlink.get(w)));
+      } else if (onStack.has(w)) {
+        nodeLowlink.set(v, Math.min(nodeLowlink.get(v), nodeIndex.get(w)));
+      }
+    }
+    if (nodeLowlink.get(v) === nodeIndex.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length >= 2) {
+        sccs.push(scc);
+      }
+    }
+  }
+  for (const file of files) {
+    if (!nodeIndex.has(file)) {
+      strongConnect(file);
+    }
+  }
+  return sccs.map((scc) => {
+    const sccSet = new Set(scc);
+    let edgeCount = 0;
+    for (const edge of graph.edges) {
+      if (sccSet.has(edge.source) && sccSet.has(edge.target)) {
+        edgeCount++;
+      }
+    }
+    return {
+      files: scc.sort(),
+      edgeCount
+    };
+  });
+}
+function computeCoupling(graph) {
+  const files = Object.keys(graph.nodes);
+  const fanIn = /* @__PURE__ */ new Map();
+  const fanOut = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    fanIn.set(file, /* @__PURE__ */ new Set());
+    fanOut.set(file, /* @__PURE__ */ new Set());
+  }
+  for (const edge of graph.edges) {
+    fanIn.get(edge.target)?.add(edge.source);
+    fanOut.get(edge.source)?.add(edge.target);
+  }
+  return files.map((file) => {
+    const ca = fanIn.get(file)?.size ?? 0;
+    const ce = fanOut.get(file)?.size ?? 0;
+    const total = ca + ce;
+    return {
+      filePath: file,
+      afferentCoupling: ca,
+      efferentCoupling: ce,
+      instability: total > 0 ? ce / total : 0
+    };
+  });
+}
+function detectHotspots(graph, pageRank) {
+  const files = Object.keys(graph.nodes);
+  const connectivity = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    connectivity.set(file, 0);
+  }
+  for (const edge of graph.edges) {
+    connectivity.set(edge.source, (connectivity.get(edge.source) ?? 0) + 1);
+    connectivity.set(edge.target, (connectivity.get(edge.target) ?? 0) + 1);
+  }
+  return files.map((file) => ({
+    filePath: file,
+    connectivity: connectivity.get(file) ?? 0,
+    pageRank: pageRank.ranks[file] ?? 0,
+    definitionCount: graph.nodes[file]?.definitionCount ?? 0
+  })).sort((a, b) => {
+    if (b.pageRank !== a.pageRank) return b.pageRank - a.pageRank;
+    if (b.connectivity !== a.connectivity) return b.connectivity - a.connectivity;
+    return b.definitionCount - a.definitionCount;
+  });
+}
+function computeMetrics(graph, pageRank) {
+  const files = Object.keys(graph.nodes);
+  const cycles = detectCycles(graph);
+  const coupling = computeCoupling(graph);
+  const hotspots = detectHotspots(graph, pageRank);
+  let totalDefinitions = 0;
+  let totalReferences = 0;
+  for (const node of Object.values(graph.nodes)) {
+    totalDefinitions += node.definitionCount;
+    totalReferences += node.referenceCount;
+  }
+  const fanIns = coupling.map((c2) => c2.afferentCoupling);
+  const fanOuts = coupling.map((c2) => c2.efferentCoupling);
+  const totalFiles = files.length;
+  return {
+    totalFiles,
+    totalEdges: graph.edges.length,
+    totalDefinitions,
+    totalReferences,
+    cycles,
+    coupling,
+    hotspots,
+    avgFanIn: totalFiles > 0 ? sum(fanIns) / totalFiles : 0,
+    avgFanOut: totalFiles > 0 ? sum(fanOuts) / totalFiles : 0,
+    maxFanIn: fanIns.length > 0 ? Math.max(...fanIns) : 0,
+    maxFanOut: fanOuts.length > 0 ? Math.max(...fanOuts) : 0
+  };
+}
+function saveMetrics(metrics, filePath) {
+  mkdirSync3(dirname3(filePath), { recursive: true });
+  writeFileSync3(filePath, JSON.stringify(metrics, null, 2), "utf-8");
+}
+function loadMetrics(filePath) {
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function sum(values) {
+  let total = 0;
+  for (const v of values) {
+    total += v;
+  }
+  return total;
+}
+
+// src/commands/serve.ts
+function text(value) {
+  return { content: [{ type: "text", text: value }] };
+}
+function json(value) {
+  return text(JSON.stringify(value, null, 2));
+}
+function resolveProjectDir(override) {
+  const dir = override || process.env["CODEMAP_PROJECT_DIR"] || process.cwd();
+  if (!fs14.existsSync(dir)) {
+    throw new Error(`Project directory not found: ${dir}`);
+  }
+  return dir;
+}
+function loadGraphSafe(projectDir, branch) {
+  try {
+    return loadGraph(depgraphGraphFile(projectDir, branch, getDataDir2()));
+  } catch {
+    return null;
+  }
+}
+function loadPageRankSafe(projectDir, branch) {
+  try {
+    return loadPageRank(depgraphPagerankFile(projectDir, branch, getDataDir2()));
+  } catch {
+    return null;
+  }
+}
+function loadMetricsSafe(projectDir, branch) {
+  try {
+    return loadMetrics(depgraphMetricsFile(projectDir, branch, getDataDir2()));
+  } catch {
+    return null;
+  }
+}
+function createCodemapMcpServer() {
+  const server = new McpServer({
+    name: "codemap",
+    version: "0.1.0"
+  });
+  const dataDir = getDataDir2();
+  server.tool(
+    "search_code",
+    "Search code using hybrid vector + BM25",
+    {
+      query: z14.string().describe("Natural language search query"),
+      limit: z14.number().int().min(1).max(50).optional().describe("Max results (default 10)"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ query, limit, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const config = loadCliConfig(projectDir);
+      bridgeEnvVars(config);
+      const branch = getCurrentBranch(projectDir);
+      const results = await searchCode(projectDir, query, {
+        limit: limit ?? 10,
+        branch,
+        dataDir
+      });
+      return json(
+        results.map((r) => ({
+          file: r.filePath,
+          lines: `${r.startLine}-${r.endLine}`,
+          score: Math.round(r.score * 1e3) / 1e3,
+          snippet: r.snippet.slice(0, 500)
+        }))
+      );
+    }
+  );
+  server.tool(
+    "search_symbols",
+    "Find functions, classes, and types by name",
+    {
+      query: z14.string().describe("Symbol name or pattern to search for"),
+      limit: z14.number().int().min(1).max(100).optional().describe("Max results (default 20)"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ query, limit, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const metaDir = codemapMetadataDir(projectDir, branch, dataDir);
+      const symbolIndex = loadSymbolIndex(metaDir);
+      const matches = searchSymbols(symbolIndex, query, limit ?? 20);
+      return json(
+        matches.map((m) => ({
+          name: m.entry.name,
+          type: m.entry.symbolType,
+          file: m.entry.filePath,
+          line: m.entry.startLine,
+          score: Math.round(m.score * 1e3) / 1e3
+        }))
+      );
+    }
+  );
+  server.tool(
+    "get_file_summary",
+    "Get file overview with symbols and size",
+    {
+      filePath: z14.string().describe("Repo-relative file path"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ filePath, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const fullPath = `${projectDir}/${filePath}`;
+      if (!fs14.existsSync(fullPath)) {
+        return text(`File not found: ${filePath}`);
+      }
+      const content = fs14.readFileSync(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const metaDir = codemapMetadataDir(projectDir, branch, dataDir);
+      const symbolIndex = loadSymbolIndex(metaDir);
+      const fileSymbols = symbolIndex.filter((s) => s.filePath === filePath);
+      return json({
+        filePath,
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        lineCount: lines.length,
+        symbols: fileSymbols.map((s) => ({
+          name: s.name,
+          type: s.symbolType,
+          line: s.startLine
+        }))
+      });
+    }
+  );
+  server.tool(
+    "get_index_stats",
+    "Get code search index statistics",
+    {
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const statsFile = codemapStatsFile(projectDir, branch, dataDir);
+      let stats = null;
+      try {
+        stats = JSON.parse(fs14.readFileSync(statsFile, "utf-8"));
+      } catch {
+      }
+      return json({ projectDir, branch, stats });
+    }
+  );
+  server.tool(
+    "reindex",
+    "Trigger a full code search re-index",
+    {
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      try {
+        await runInitPipeline(projectDir, void 0, { dataDir });
+        return text(`Reindex complete for ${projectDir}`);
+      } catch (err) {
+        return text(`Reindex failed: ${String(err)}`);
+      }
+    }
+  );
+  server.tool(
+    "get_dependencies",
+    "Get files this file imports (outgoing edges)",
+    {
+      filePath: z14.string().describe("Repo-relative file path"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ filePath, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const graph = loadGraphSafe(projectDir, branch);
+      if (!graph) return text("Dependency graph not available. Run reindex first.");
+      const outgoing = getOutgoingEdges(graph, filePath);
+      return json(outgoing.map((e) => ({ target: e.target, symbols: e.symbols })));
+    }
+  );
+  server.tool(
+    "get_dependents",
+    "Get files that import this file (incoming edges)",
+    {
+      filePath: z14.string().describe("Repo-relative file path"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ filePath, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const graph = loadGraphSafe(projectDir, branch);
+      if (!graph) return text("Dependency graph not available. Run reindex first.");
+      const incoming = getIncomingEdges(graph, filePath);
+      return json(incoming.map((e) => ({ source: e.source, symbols: e.symbols })));
+    }
+  );
+  server.tool(
+    "get_file_rank",
+    "Get PageRank importance score for files",
+    {
+      filePath: z14.string().optional().describe("Specific file (omit for top-ranked files)"),
+      limit: z14.number().int().min(1).max(100).optional().describe("Number of top files (default 20)"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ filePath, limit, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const pageRank = loadPageRankSafe(projectDir, branch);
+      if (!pageRank) return text("PageRank not available. Run rebuild_depgraph first.");
+      if (filePath) {
+        const rank = pageRank.ranks[filePath] ?? 0;
+        return json({ filePath, rank });
+      }
+      const sorted = Object.entries(pageRank.ranks).sort(([, a], [, b]) => b - a).slice(0, limit ?? 20);
+      return json(sorted.map(([file, rank]) => ({
+        filePath: file,
+        rank: Math.round(rank * 1e4) / 1e4
+      })));
+    }
+  );
+  server.tool(
+    "find_cycles",
+    "Detect circular dependencies",
+    {
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const graph = loadGraphSafe(projectDir, branch);
+      if (!graph) return text("Dependency graph not available. Run reindex first.");
+      const cycles = detectCycles(graph);
+      return json({
+        cycleCount: cycles.length,
+        cycles: cycles.map((c) => ({ files: c.files, edgeCount: c.edgeCount }))
+      });
+    }
+  );
+  server.tool(
+    "get_coupling_metrics",
+    "Analyze afferent/efferent coupling and instability",
+    {
+      modulePath: z14.string().optional().describe("Filter to a directory prefix (e.g. src/routes/)"),
+      limit: z14.number().int().min(1).max(200).optional().describe("Max results (default 50)"),
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ modulePath, limit, projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const graph = loadGraphSafe(projectDir, branch);
+      if (!graph) return text("Dependency graph not available. Run reindex first.");
+      let coupling = computeCoupling(graph);
+      if (modulePath) coupling = coupling.filter((c) => c.filePath.startsWith(modulePath));
+      coupling.sort((a, b) => b.instability - a.instability);
+      coupling = coupling.slice(0, limit ?? 50);
+      return json(coupling.map((c) => ({
+        file: c.filePath,
+        fanIn: c.afferentCoupling,
+        fanOut: c.efferentCoupling,
+        instability: Math.round(c.instability * 1e3) / 1e3
+      })));
+    }
+  );
+  server.tool(
+    "get_depgraph_stats",
+    "Get aggregate dependency graph statistics",
+    {
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const metrics = loadMetricsSafe(projectDir, branch);
+      if (!metrics) return text("Dependency metrics not available. Run rebuild_depgraph first.");
+      return json({
+        totalFiles: metrics.totalFiles,
+        totalEdges: metrics.totalEdges,
+        totalDefinitions: metrics.totalDefinitions,
+        totalReferences: metrics.totalReferences,
+        cycleCount: metrics.cycles.length,
+        avgFanIn: Math.round(metrics.avgFanIn * 100) / 100,
+        avgFanOut: Math.round(metrics.avgFanOut * 100) / 100,
+        maxFanIn: metrics.maxFanIn,
+        maxFanOut: metrics.maxFanOut,
+        hotspots: metrics.hotspots.slice(0, 10).map((h) => ({
+          file: h.filePath,
+          connectivity: h.connectivity,
+          pageRank: Math.round(h.pageRank * 1e4) / 1e4
+        }))
+      });
+    }
+  );
+  server.tool(
+    "rebuild_depgraph",
+    "Recompute PageRank and dependency metrics",
+    {
+      projectDir: z14.string().optional().describe("Project directory (default: cwd)")
+    },
+    async ({ projectDir: pd }) => {
+      const projectDir = resolveProjectDir(pd);
+      const branch = getCurrentBranch(projectDir);
+      const graph = loadGraphSafe(projectDir, branch);
+      if (!graph) {
+        return text("No dependency graph data found. Run reindex first to generate the graph data.");
+      }
+      const pageRank = computePageRank(graph);
+      savePageRank(pageRank, depgraphPagerankFile(projectDir, branch, dataDir));
+      const metrics = computeMetrics(graph, pageRank);
+      saveMetrics(metrics, depgraphMetricsFile(projectDir, branch, dataDir));
+      return json({
+        message: "Dependency graph metrics rebuilt",
+        totalFiles: Object.keys(graph.nodes).length,
+        totalEdges: graph.edges.length,
+        cycleCount: metrics.cycles.length
+      });
+    }
+  );
+  return server;
+}
+function registerServe(program2) {
+  program2.command("serve").description("Start MCP server over stdio (for AI agent integration)").action(async () => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    bridgeEnvVars(config);
+    writeCodemapIgnore(projectDir);
+    const server = createCodemapMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  });
+}
+
+// src/commands/deps.ts
+import chalk7 from "chalk";
+function registerDeps(program2) {
+  program2.command("deps <file>").description("Show files this file depends on (outgoing imports)").option("--json", "Output as JSON").action(async (file, opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const graphFile = depgraphGraphFile(projectDir, branch, getDataDir2());
+    let graph;
+    try {
+      graph = loadGraph(graphFile);
+    } catch {
+      console.error(chalk7.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    if (!graph) {
+      console.error(chalk7.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    const edges = getOutgoingEdges(graph, file);
+    if (opts.json) {
+      console.log(JSON.stringify(edges.map((e) => ({
+        target: e.target,
+        symbols: e.symbols
+      })), null, 2));
+      return;
+    }
+    if (edges.length === 0) {
+      console.log(chalk7.yellow(`No dependencies found for ${file}`));
+      return;
+    }
+    console.log(chalk7.bold(`Dependencies of ${chalk7.cyan(file)}`));
+    console.log();
+    for (const e of edges) {
+      console.log(`  ${chalk7.cyan(e.target)}`);
+      if (e.symbols.length > 0) {
+        console.log(chalk7.dim(`    symbols: ${e.symbols.join(", ")}`));
+      }
+    }
+  });
+}
+
+// src/commands/dependents.ts
+import chalk8 from "chalk";
+function registerDependents(program2) {
+  program2.command("dependents <file>").description("Show files that depend on this file (incoming imports)").option("--json", "Output as JSON").action(async (file, opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const graphFile = depgraphGraphFile(projectDir, branch, getDataDir2());
+    let graph;
+    try {
+      graph = loadGraph(graphFile);
+    } catch {
+      console.error(chalk8.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    if (!graph) {
+      console.error(chalk8.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    const edges = getIncomingEdges(graph, file);
+    if (opts.json) {
+      console.log(JSON.stringify(edges.map((e) => ({
+        source: e.source,
+        symbols: e.symbols
+      })), null, 2));
+      return;
+    }
+    if (edges.length === 0) {
+      console.log(chalk8.yellow(`No dependents found for ${file}`));
+      return;
+    }
+    console.log(chalk8.bold(`Dependents of ${chalk8.cyan(file)}`));
+    console.log();
+    for (const e of edges) {
+      console.log(`  ${chalk8.cyan(e.source)}`);
+      if (e.symbols.length > 0) {
+        console.log(chalk8.dim(`    symbols: ${e.symbols.join(", ")}`));
+      }
+    }
+  });
+}
+
+// src/commands/rank.ts
+import chalk9 from "chalk";
+function registerRank(program2) {
+  program2.command("rank [file]").description("Show PageRank importance scores (top files or single file)").option("-l, --limit <n>", "Number of top files to show", "20").option("--json", "Output as JSON").action(async (file, opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const prFile = depgraphPagerankFile(projectDir, branch, getDataDir2());
+    let pageRank;
+    try {
+      pageRank = loadPageRank(prFile);
+    } catch {
+      console.error(chalk9.red("PageRank not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    if (!pageRank) {
+      console.error(chalk9.red("PageRank not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    if (file) {
+      const rank = pageRank.ranks[file] ?? 0;
+      if (opts.json) {
+        console.log(JSON.stringify({ filePath: file, rank }));
+        return;
+      }
+      console.log(`${chalk9.cyan(file)}: ${chalk9.bold(String(Math.round(rank * 1e4) / 1e4))}`);
+      return;
+    }
+    const limit = parseInt(opts.limit, 10);
+    const sorted = Object.entries(pageRank.ranks).sort(([, a], [, b]) => b - a).slice(0, limit);
+    if (opts.json) {
+      console.log(JSON.stringify(sorted.map(([f, r]) => ({
+        filePath: f,
+        rank: Math.round(r * 1e4) / 1e4
+      })), null, 2));
+      return;
+    }
+    console.log(chalk9.bold("Top files by PageRank"));
+    console.log(chalk9.dim("-".repeat(60)));
+    for (const [f, r] of sorted) {
+      const rank = Math.round(r * 1e4) / 1e4;
+      console.log(`  ${String(rank).padStart(8)}  ${chalk9.cyan(f)}`);
+    }
+  });
+}
+
+// src/commands/cycles.ts
+import chalk10 from "chalk";
+function registerCycles(program2) {
+  program2.command("cycles").description("Detect circular dependencies in the codebase").option("--json", "Output as JSON").action(async (opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const branch = getCurrentBranch(projectDir);
+    const graphFile = depgraphGraphFile(projectDir, branch, getDataDir2());
+    let graph;
+    try {
+      graph = loadGraph(graphFile);
+    } catch {
+      console.error(chalk10.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    if (!graph) {
+      console.error(chalk10.red("Dependency graph not available. Run `codemap index` first."));
+      process.exit(1);
+      return;
+    }
+    const cycles = detectCycles(graph);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        cycleCount: cycles.length,
+        cycles: cycles.map((c) => ({
+          files: c.files,
+          edgeCount: c.edgeCount
+        }))
+      }, null, 2));
+      return;
+    }
+    if (cycles.length === 0) {
+      console.log(chalk10.green("No circular dependencies found."));
+      return;
+    }
+    console.log(chalk10.bold(`Found ${chalk10.red(String(cycles.length))} circular dependencies:`));
+    console.log();
+    for (let i = 0; i < cycles.length; i++) {
+      const c = cycles[i];
+      console.log(chalk10.yellow(`Cycle ${i + 1}`) + chalk10.dim(` (${c.edgeCount} edges)`));
+      for (const f of c.files) {
+        console.log(`  ${chalk10.cyan(f)}`);
+      }
+      console.log();
+    }
+  });
+}
+
+// src/commands/config-cmd.ts
+import chalk11 from "chalk";
+function registerConfig(program2) {
+  const cmd = program2.command("config").description("Get, set, or list configuration values");
+  cmd.command("list").description("Show all configuration values").action(() => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    console.log(chalk11.bold("Configuration") + chalk11.dim(` (${globalConfigFile()})`));
+    console.log(JSON.stringify(config, null, 2));
+  });
+  cmd.command("get <key>").description("Get a configuration value (e.g., embedding.provider)").action((key) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    const value = getNestedValue(config, key);
+    if (value === void 0) {
+      console.log(chalk11.yellow(`Key "${key}" is not set`));
+    } else {
+      console.log(String(value));
+    }
+  });
+  cmd.command("set <key> <value>").description("Set a configuration value (e.g., embedding.provider openai)").action((key, value) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const config = loadCliConfig(projectDir);
+    setNestedValue(config, key, value);
+    saveCliConfig(config);
+    console.log(chalk11.green(`Set ${key} = ${value}`));
+  });
+}
+function getNestedValue(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, key, value) {
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  const numVal = Number(value);
+  if (!isNaN(numVal) && value.trim() !== "") {
+    current[lastKey] = numVal;
+  } else if (value === "true") {
+    current[lastKey] = true;
+  } else if (value === "false") {
+    current[lastKey] = false;
+  } else {
+    current[lastKey] = value;
+  }
+}
+
+// src/commands/ignore.ts
+import fs15 from "fs";
+import path10 from "path";
+import chalk12 from "chalk";
+function registerIgnore(program2) {
+  program2.command("ignore").description("Generate or reset .codemapignore with default patterns").option("--force", "Overwrite existing .codemapignore").action((opts) => {
+    const projectDir = program2.opts().cwd || process.cwd();
+    const ignorePath = path10.join(projectDir, ".codemapignore");
+    const exists = fs15.existsSync(ignorePath);
+    if (exists && !opts.force) {
+      console.log(chalk12.yellow(".codemapignore already exists."));
+      console.log(chalk12.dim("Use --force to overwrite with the default template."));
+      return;
+    }
+    writeCodemapIgnore(projectDir, true);
+    if (exists) {
+      console.log(chalk12.green("Regenerated ") + chalk12.cyan(".codemapignore") + chalk12.green(" with default patterns"));
+    } else {
+      console.log(chalk12.green("Created ") + chalk12.cyan(".codemapignore") + chalk12.green(" with default patterns"));
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("codemap").description("Code intelligence CLI \u2014 hybrid search, dependency analysis, PageRank").version("0.1.0").option("--cwd <dir>", "Project directory (default: cwd)");
+registerSearch(program);
+registerSymbols(program);
+registerIndex(program);
+registerWatch(program);
+registerStatus(program);
+registerServe(program);
+registerDeps(program);
+registerDependents(program);
+registerRank(program);
+registerCycles(program);
+registerConfig(program);
+registerInit(program);
+registerIgnore(program);
+program.parse();