sparkecoder 0.1.24 → 0.1.26

package/dist/tools/index.js

@@ -55,6 +55,53 @@ var SessionConfigSchema = z.object({
   skillsDirectory: z.string().optional(),
   maxContextChars: z.number().optional().default(2e5)
 });
+var VectorGatewayConfigSchema = z.object({
+  // Redis URL for Vector Gateway (or use VECTOR_REDIS_URL env var)
+  redisUrl: z.string().optional(),
+  // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
+  httpUrl: z.string().optional(),
+  // Embedding model to use (default: text-embedding-3-small)
+  embeddingModel: z.string().default("gemini-embedding-001"),
+  // Custom namespace override (auto-generated from git remote if not set)
+  namespace: z.string().optional(),
+  // File patterns to include in indexing
+  include: z.array(z.string()).optional().default([
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.py",
+    "**/*.go",
+    "**/*.rs",
+    "**/*.java",
+    "**/*.md",
+    "**/*.mdx",
+    "**/*.txt"
+  ]),
+  // File patterns to exclude from indexing
+  exclude: z.array(z.string()).optional().default([
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/.next/**",
+    "**/*.min.js",
+    "**/*.bundle.js",
+    "**/pnpm-lock.yaml",
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/.test-workspace/**",
+    "**/.semantic-test-workspace/**",
+    "**/.semantic-integration-test/**"
+  ])
+}).optional();
+var RemoteServerConfigSchema = z.object({
+  // URL of the remote server (e.g., https://agent.sparkecode.com)
+  url: z.string().url().optional(),
+  // Auth key for the remote server (auto-generated on first use if not set)
+  // Can also be set via SPARKECODER_AUTH_KEY env var
+  authKey: z.string().optional()
+}).optional();
 var SparkcoderConfigSchema = z.object({
   // Default model to use (Vercel AI Gateway format)
   defaultModel: z.string().default("anthropic/claude-opus-4-5"),
@@ -88,8 +135,13 @@ var SparkcoderConfigSchema = z.object({
     // If not set, defaults to http://{host}:{port}
     publicUrl: z.string().url().optional()
   }).default({ port: 3141, host: "127.0.0.1" }),
-  // Database path
-  databasePath: z.string().optional().default("./sparkecoder.db")
+  // Database path (used for local SQLite - ignored if remoteServer is configured)
+  databasePath: z.string().optional().default("./sparkecoder.db"),
+  // Remote server configuration (for centralized storage)
+  // If configured, uses remote MongoDB instead of local SQLite
+  remoteServer: RemoteServerConfigSchema,
+  // Vector Gateway configuration for semantic search
+  vectorGateway: VectorGatewayConfigSchema
 });
 
 // src/config/index.ts
@@ -104,6 +156,13 @@ function getAppDataDirectory() {
       return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
   }
 }
+var cachedConfig = null;
+function getConfig() {
+  if (!cachedConfig) {
+    throw new Error("Config not loaded. Call loadConfig first.");
+  }
+  return cachedConfig;
+}
 var PROVIDER_ENV_MAP = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
@@ -716,323 +775,174 @@ import { resolve as resolve3, relative as relative2, dirname as dirname2 } from
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 
-// src/db/index.ts
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { eq, desc, and, sql } from "drizzle-orm";
-import { nanoid as nanoid2 } from "nanoid";
-
-// src/db/schema.ts
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  name: text("name"),
-  workingDirectory: text("working_directory").notNull(),
-  model: text("model").notNull(),
-  status: text("status", { enum: ["active", "waiting", "completed", "error"] }).notNull().default("active"),
-  config: text("config", { mode: "json" }).$type(),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var messages = sqliteTable("messages", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // Store the entire ModelMessage as JSON (role + content)
-  modelMessage: text("model_message", { mode: "json" }).$type().notNull(),
-  // Sequence number within session to maintain exact ordering
-  sequence: integer("sequence").notNull().default(0),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var toolExecutions = sqliteTable("tool_executions", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  messageId: text("message_id").references(() => messages.id, { onDelete: "cascade" }),
-  toolName: text("tool_name").notNull(),
-  toolCallId: text("tool_call_id").notNull(),
-  input: text("input", { mode: "json" }),
-  output: text("output", { mode: "json" }),
-  status: text("status", { enum: ["pending", "approved", "rejected", "completed", "error"] }).notNull().default("pending"),
-  requiresApproval: integer("requires_approval", { mode: "boolean" }).notNull().default(false),
-  error: text("error"),
-  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  completedAt: integer("completed_at", { mode: "timestamp" })
-});
-var todoItems = sqliteTable("todo_items", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  content: text("content").notNull(),
-  status: text("status", { enum: ["pending", "in_progress", "completed", "cancelled"] }).notNull().default("pending"),
-  order: integer("order").notNull().default(0),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var loadedSkills = sqliteTable("loaded_skills", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  skillName: text("skill_name").notNull(),
-  loadedAt: integer("loaded_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var terminals = sqliteTable("terminals", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  name: text("name"),
-  // Optional friendly name (e.g., "dev-server")
-  command: text("command").notNull(),
-  // The command that was run
-  cwd: text("cwd").notNull(),
-  // Working directory
-  pid: integer("pid"),
-  // Process ID (null if not running)
-  status: text("status", { enum: ["running", "stopped", "error"] }).notNull().default("running"),
-  exitCode: integer("exit_code"),
-  // Exit code if stopped
-  error: text("error"),
-  // Error message if status is 'error'
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  stoppedAt: integer("stopped_at", { mode: "timestamp" })
-});
-var activeStreams = sqliteTable("active_streams", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  streamId: text("stream_id").notNull().unique(),
-  // Unique stream identifier
-  status: text("status", { enum: ["active", "finished", "error"] }).notNull().default("active"),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  finishedAt: integer("finished_at", { mode: "timestamp" })
-});
-var checkpoints = sqliteTable("checkpoints", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // The message sequence number this checkpoint was created BEFORE
-  // (i.e., the state before this user message was processed)
-  messageSequence: integer("message_sequence").notNull(),
-  // Optional git commit hash if in a git repo
-  gitHead: text("git_head"),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var fileBackups = sqliteTable("file_backups", {
-  id: text("id").primaryKey(),
-  checkpointId: text("checkpoint_id").notNull().references(() => checkpoints.id, { onDelete: "cascade" }),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // Relative path from working directory
-  filePath: text("file_path").notNull(),
-  // Original content (null means file didn't exist before)
-  originalContent: text("original_content"),
-  // Whether the file existed before this checkpoint
-  existed: integer("existed", { mode: "boolean" }).notNull().default(true),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var subagentExecutions = sqliteTable("subagent_executions", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  toolCallId: text("tool_call_id").notNull(),
-  // The tool call that spawned this subagent
-  subagentType: text("subagent_type").notNull(),
-  // e.g., 'search', 'analyze', etc.
-  task: text("task").notNull(),
-  // The task/query given to the subagent
-  model: text("model").notNull(),
-  // The model used (e.g., 'gemini-2.0-flash')
-  status: text("status", { enum: ["running", "completed", "error", "cancelled"] }).notNull().default("running"),
-  // Steps taken by the subagent (stored as JSON array)
-  steps: text("steps", { mode: "json" }).$type().default([]),
-  // Final result/output
-  result: text("result", { mode: "json" }),
-  error: text("error"),
-  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  completedAt: integer("completed_at", { mode: "timestamp" })
-});
-
-// src/db/index.ts
-var db = null;
-function getDb() {
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase first.");
+// src/db/remote.ts
+var remoteServerUrl = null;
+var authKey = null;
+var DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
+function parseDates(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(parseDates);
+  if (typeof obj !== "object") return obj;
+  const result = { ...obj };
+  for (const key of Object.keys(result)) {
+    if (DATE_FIELDS.includes(key) && typeof result[key] === "string") {
+      result[key] = new Date(result[key]);
+    } else if (typeof result[key] === "object") {
+      result[key] = parseDates(result[key]);
+    }
   }
-  return db;
+  return result;
 }
-var todoQueries = {
+async function api(path, options = {}) {
+  if (!remoteServerUrl || !authKey) {
+    throw new Error("Remote database not initialized");
+  }
+  const url = `${remoteServerUrl}/db${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+  const text = await response.text();
+  if (!text || text === "null") {
+    return null;
+  }
+  return parseDates(JSON.parse(text));
+}
+var remoteTodoQueries = {
   create(data) {
-    const id = nanoid2();
-    const now = /* @__PURE__ */ new Date();
-    const result = getDb().insert(todoItems).values({
-      id,
-      ...data,
-      createdAt: now,
-      updatedAt: now
-    }).returning().get();
-    return result;
+    return api("/todos", { method: "POST", body: data });
   },
   createMany(sessionId, items) {
-    const now = /* @__PURE__ */ new Date();
-    const values = items.map((item, index) => ({
-      id: nanoid2(),
-      sessionId,
-      content: item.content,
-      order: item.order ?? index,
-      createdAt: now,
-      updatedAt: now
-    }));
-    return getDb().insert(todoItems).values(values).returning().all();
+    return api("/todos/batch", { method: "POST", body: { sessionId, items } });
   },
   getBySession(sessionId) {
-    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+    return api(`/todos/session/${sessionId}`);
   },
   updateStatus(id, status) {
-    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+    return api(`/todos/${id}`, { method: "PATCH", body: { status } });
   },
-  delete(id) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
-    return result.changes > 0;
+  async delete(id) {
+    const result = await api(`/todos/${id}`, { method: "DELETE" });
+    return result?.success ?? false;
   },
-  clearSession(sessionId) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
-    return result.changes;
+  async clearSession(sessionId) {
+    const result = await api(`/todos/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var skillQueries = {
+var remoteSkillQueries = {
   load(sessionId, skillName) {
-    const id = nanoid2();
-    const result = getDb().insert(loadedSkills).values({
-      id,
-      sessionId,
-      skillName,
-      loadedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/skills", { method: "POST", body: { sessionId, skillName } });
   },
   getBySession(sessionId) {
-    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+    return api(`/skills/session/${sessionId}`);
   },
-  isLoaded(sessionId, skillName) {
-    const result = getDb().select().from(loadedSkills).where(
-      and(
-        eq(loadedSkills.sessionId, sessionId),
-        eq(loadedSkills.skillName, skillName)
-      )
-    ).get();
-    return !!result;
+  async isLoaded(sessionId, skillName) {
+    const result = await api(`/skills/session/${sessionId}/is-loaded/${skillName}`);
+    return result.isLoaded;
   }
 };
-var fileBackupQueries = {
+var remoteFileBackupQueries = {
   create(data) {
-    const id = nanoid2();
-    const result = getDb().insert(fileBackups).values({
-      id,
-      checkpointId: data.checkpointId,
-      sessionId: data.sessionId,
-      filePath: data.filePath,
-      originalContent: data.originalContent,
-      existed: data.existed,
-      createdAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/file-backups", { method: "POST", body: data });
   },
   getByCheckpoint(checkpointId) {
-    return getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, checkpointId)).all();
+    return api(`/file-backups/checkpoint/${checkpointId}`);
   },
   getBySession(sessionId) {
-    return getDb().select().from(fileBackups).where(eq(fileBackups.sessionId, sessionId)).orderBy(fileBackups.createdAt).all();
+    return api(`/file-backups/session/${sessionId}`);
   },
-  /**
-   * Get all file backups from a given checkpoint sequence onwards (inclusive)
-   * (Used when reverting - need to restore these files)
-   * 
-   * When reverting to checkpoint X, we need backups from checkpoint X and all later ones
-   * because checkpoint X's backups represent the state BEFORE processing message X.
-   */
   getFromSequence(sessionId, messageSequence) {
-    const checkpointsFrom = getDb().select().from(checkpoints).where(
-      and(
-        eq(checkpoints.sessionId, sessionId),
-        sql`message_sequence >= ${messageSequence}`
-      )
-    ).all();
-    if (checkpointsFrom.length === 0) {
-      return [];
-    }
-    const checkpointIds = checkpointsFrom.map((c) => c.id);
-    const allBackups = [];
-    for (const cpId of checkpointIds) {
-      const backups = getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, cpId)).all();
-      allBackups.push(...backups);
-    }
-    return allBackups;
+    return api(`/file-backups/session/${sessionId}/from-sequence/${messageSequence}`);
   },
-  /**
-   * Check if a file already has a backup in the current checkpoint
-   */
-  hasBackup(checkpointId, filePath) {
-    const result = getDb().select().from(fileBackups).where(
-      and(
-        eq(fileBackups.checkpointId, checkpointId),
-        eq(fileBackups.filePath, filePath)
-      )
-    ).get();
-    return !!result;
+  async hasBackup(checkpointId, filePath) {
+    const result = await api(
+      `/file-backups/checkpoint/${checkpointId}/has-backup/${encodeURIComponent(filePath)}`
+    );
+    return result.hasBackup;
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(fileBackups).where(eq(fileBackups.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/file-backups/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var subagentQueries = {
+var remoteSubagentQueries = {
   create(data) {
-    const id = nanoid2();
-    const result = getDb().insert(subagentExecutions).values({
-      id,
-      sessionId: data.sessionId,
-      toolCallId: data.toolCallId,
-      subagentType: data.subagentType,
-      task: data.task,
-      model: data.model,
-      status: "running",
-      steps: [],
-      startedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/subagents", { method: "POST", body: data });
   },
   getById(id) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.id, id)).get();
+    return api(`/subagents/${id}`).catch(() => void 0);
   },
   getByToolCallId(toolCallId) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.toolCallId, toolCallId)).get();
+    return api(`/subagents/by-tool-call-id/${toolCallId}`).catch(() => void 0);
   },
   getBySession(sessionId) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).orderBy(desc(subagentExecutions.startedAt)).all();
+    return api(`/subagents/session/${sessionId}`);
   },
   addStep(id, step) {
-    const existing = this.getById(id);
-    if (!existing) return void 0;
-    const currentSteps = existing.steps || [];
-    const newSteps = [...currentSteps, step];
-    return getDb().update(subagentExecutions).set({ steps: newSteps }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}/add-step`, { method: "POST", body: { step } }).catch(() => void 0);
   },
   complete(id, result) {
-    return getDb().update(subagentExecutions).set({
-      status: "completed",
-      result,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "completed", result } }).catch(() => void 0);
   },
   markError(id, error) {
-    return getDb().update(subagentExecutions).set({
-      status: "error",
-      error,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "error", error } }).catch(() => void 0);
   },
   cancel(id) {
-    return getDb().update(subagentExecutions).set({
-      status: "cancelled",
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "cancelled" } }).catch(() => void 0);
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/subagents/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
+var remoteIndexStatusQueries = {
+  upsert(_db, data) {
+    return api("/index-status", {
+      method: "POST",
+      body: {
+        ...data,
+        lastFullIndex: data.lastFullIndex?.toISOString(),
+        lastIncrementalIndex: data.lastIncrementalIndex?.toISOString()
+      }
+    });
+  },
+  get(_db, namespace) {
+    return api(`/index-status/namespace/${namespace}`).then((r) => r ?? void 0);
+  },
+  async delete(_db, namespace) {
+    const result = await api(`/index-status/namespace/${namespace}`, { method: "DELETE" });
+    return result?.success ?? false;
+  },
+  list(_db) {
+    return api("/index-status");
+  }
+};
+
+// src/db/index.ts
+var initialized = false;
+function getDb() {
+  if (!initialized) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return {};
+}
+var todoQueries = remoteTodoQueries;
+var skillQueries = remoteSkillQueries;
+var fileBackupQueries = remoteFileBackupQueries;
+var subagentQueries = remoteSubagentQueries;
+var indexStatusQueries = remoteIndexStatusQueries;
 
 // src/checkpoints/index.ts
 var execAsync3 = promisify3(exec3);
@@ -1057,7 +967,7 @@ async function backupFile(sessionId, workingDirectory, filePath) {
   }
   const absolutePath = resolve3(workingDirectory, filePath);
   const relativePath = relative2(workingDirectory, absolutePath);
-  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+  if (await fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
     return null;
   }
   let originalContent = null;
@@ -1070,7 +980,7 @@ async function backupFile(sessionId, workingDirectory, filePath) {
       console.warn(`[checkpoint] Failed to read file for backup: ${error.message}`);
     }
   }
-  const backup = fileBackupQueries.create({
+  const backup = await fileBackupQueries.create({
     checkpointId: manager.currentCheckpointId,
     sessionId,
     filePath: relativePath,
@@ -1827,7 +1737,7 @@ Best practices:
                 error: "No items provided. Include at least one todo item."
               };
             }
-            const created = todoQueries.createMany(options.sessionId, items);
+            const created = await todoQueries.createMany(options.sessionId, items);
             return {
               success: true,
               action: "add",
@@ -1836,7 +1746,7 @@ Best practices:
             };
           }
           case "list": {
-            const todos = todoQueries.getBySession(options.sessionId);
+            const todos = await todoQueries.getBySession(options.sessionId);
             const stats = {
               total: todos.length,
               pending: todos.filter((t) => t.status === "pending").length,
@@ -1864,7 +1774,7 @@ Best practices:
                 error: 'status is required for "mark" action'
               };
             }
-            const updated = todoQueries.updateStatus(todoId, status);
+            const updated = await todoQueries.updateStatus(todoId, status);
             if (!updated) {
               return {
                 success: false,
@@ -1878,7 +1788,7 @@ Best practices:
             };
           }
           case "clear": {
-            const count = todoQueries.clearSession(options.sessionId);
+            const count = await todoQueries.clearSession(options.sessionId);
             return {
               success: true,
               action: "clear",
@@ -2130,7 +2040,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
                 error: 'skillName is required for "load" action'
               };
             }
-            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+            if (await skillQueries.isLoaded(options.sessionId, skillName)) {
               return {
                 success: false,
                 error: `Skill "${skillName}" is already loaded in this session`
@@ -2145,7 +2055,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
                 availableSkills: allSkills.map((s) => s.name)
               };
             }
-            skillQueries.load(options.sessionId, skillName);
+            await skillQueries.load(options.sessionId, skillName);
             return {
               success: true,
               action: "load",
@@ -2373,7 +2283,7 @@ import {
   generateText,
   stepCountIs
 } from "ai";
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 
 // src/agent/model.ts
 import { gateway } from "@ai-sdk/gateway";
@@ -2399,8 +2309,8 @@ var Subagent = class {
    * Parse the final result from the subagent's output.
    * Override this to structure the result for your subagent type.
    */
-  parseResult(text2, steps) {
-    return { text: text2, steps };
+  parseResult(text, steps) {
+    return { text, steps };
   }
   /**
    * Run the subagent with streaming progress updates
@@ -2408,7 +2318,7 @@ var Subagent = class {
   async run(options) {
     const { task, sessionId, toolCallId, onProgress, abortSignal } = options;
     const steps = [];
-    const execution = subagentQueries.create({
+    const execution = await subagentQueries.create({
       sessionId,
       toolCallId,
       subagentType: this.type,
@@ -2417,12 +2327,12 @@ var Subagent = class {
     });
     const addStep = async (step) => {
       const fullStep = {
-        id: nanoid3(8),
+        id: nanoid2(8),
         timestamp: Date.now(),
         ...step
       };
       steps.push(fullStep);
-      subagentQueries.addStep(execution.id, fullStep);
+      await subagentQueries.addStep(execution.id, fullStep);
       await onProgress?.({
         type: "step",
         subagentId: execution.id,
@@ -2492,7 +2402,7 @@ var Subagent = class {
         }
       });
       const parsedResult = this.parseResult(result.text, steps);
-      subagentQueries.complete(execution.id, parsedResult);
+      await subagentQueries.complete(execution.id, parsedResult);
       await onProgress?.({
         type: "complete",
         subagentId: execution.id,
@@ -2507,7 +2417,7 @@ var Subagent = class {
       };
     } catch (error) {
       const errorMessage = error.message || "Unknown error";
-      subagentQueries.markError(execution.id, errorMessage);
+      await subagentQueries.markError(execution.id, errorMessage);
       await onProgress?.({
         type: "error",
         subagentId: execution.id,
@@ -2817,7 +2727,7 @@ Keep your responses concise and focused on actionable information.`;
       })
     };
   }
-  parseResult(text2, steps) {
+  parseResult(text, steps) {
     const findings = [];
     let filesSearched = 0;
     let matchCount = 0;
@@ -2861,7 +2771,7 @@ Keep your responses concise and focused on actionable information.`;
     const query = steps.length > 0 ? steps.find((s) => s.type === "text")?.content || "" : "";
     return {
       query,
-      summary: text2,
+      summary: text,
       findings: findings.slice(0, 20),
       // Limit findings
       filesSearched,
@@ -2992,9 +2902,362 @@ Context: ${context}` : query;
   });
 }
 
+// src/tools/semantic-search.ts
+import { tool as tool9 } from "ai";
+import { z as z10 } from "zod";
+import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
+
+// src/semantic/namespace.ts
+import { execSync } from "child_process";
+function getGitRemoteUrl(workingDirectory) {
+  try {
+    const result = execSync("git remote get-url origin", {
+      cwd: workingDirectory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(url) {
+  const cleanUrl = url.replace(/\.git$/, "");
+  const sshMatch = cleanUrl.match(/git@[^:]+:([^/]+)\/(.+)$/);
+  if (sshMatch) {
+    return { org: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = cleanUrl.match(/https?:\/\/[^/]+\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return { org: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshProtoMatch = cleanUrl.match(/ssh:\/\/[^/]+\/([^/]+)\/(.+)$/);
+  if (sshProtoMatch) {
+    return { org: sshProtoMatch[1], repo: sshProtoMatch[2] };
+  }
+  return null;
+}
+function sanitizeForNamespace(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+async function getRepoNamespace(workingDirectory, configuredNamespace) {
+  if (configuredNamespace) {
+    return configuredNamespace;
+  }
+  const remoteUrl = getGitRemoteUrl(workingDirectory);
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseGitRemoteUrl(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  const org = sanitizeForNamespace(parsed.org);
+  const repo = sanitizeForNamespace(parsed.repo);
+  return `sparkecoder_${org}_${repo}`;
+}
+
+// src/semantic/hasher.ts
+import { createHash } from "crypto";
+
+// src/semantic/chunker.ts
+import { extname as extname6, basename as basename2 } from "path";
+
+// src/semantic/client.ts
+var remoteServerUrl2 = null;
+var authKey2 = null;
+function initVectorClient(serverUrl, key) {
+  remoteServerUrl2 = serverUrl.replace(/\/$/, "");
+  authKey2 = key;
+}
+function isVectorClientConfigured() {
+  return !!remoteServerUrl2 && !!authKey2;
+}
+async function vectorApi(path, options = {}) {
+  if (!remoteServerUrl2 || !authKey2) {
+    throw new Error("Vector client not initialized - remote server not configured");
+  }
+  const url = `${remoteServerUrl2}/vectors${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey2}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+var remoteVectorClient = {
+  embeddings: {
+    /**
+     * Create embeddings and store in vector DB
+     */
+    async createAndWait(texts, options) {
+      return vectorApi("/embed", {
+        method: "POST",
+        body: {
+          texts,
+          namespace: options.namespace,
+          embeddingModel: options.embeddingModel
+        }
+      });
+    }
+  },
+  search: {
+    /**
+     * Query vectors using semantic search
+     */
+    async queryAndWait(query, options) {
+      return vectorApi("/search", {
+        method: "POST",
+        body: {
+          query,
+          namespace: options.namespace,
+          topK: options.topK || 10,
+          embeddingModel: options.embeddingModel
+        }
+      });
+    }
+  },
+  /**
+   * Delete a namespace (if supported)
+   */
+  async deleteNamespace(namespace) {
+    await vectorApi(`/namespace/${encodeURIComponent(namespace)}`, {
+      method: "DELETE"
+    });
+  },
+  /**
+   * Close client (no-op for HTTP client)
+   */
+  async close() {
+  }
+};
+function getVectorClient() {
+  if (!isVectorClientConfigured()) {
+    try {
+      const config = getConfig();
+      if (config.resolvedRemoteServer.url && config.resolvedRemoteServer.authKey) {
+        initVectorClient(config.resolvedRemoteServer.url, config.resolvedRemoteServer.authKey);
+      } else {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  return remoteVectorClient;
+}
+async function closeVectorClient() {
+}
+function isVectorGatewayConfigured() {
+  try {
+    const config = getConfig();
+    return !!(config.resolvedRemoteServer.url && config.resolvedRemoteServer.authKey);
+  } catch {
+    return false;
+  }
+}
+function getEmbeddingModel() {
+  try {
+    const config = getConfig();
+    return config.resolvedVectorGateway.embeddingModel;
+  } catch {
+    return "gemini-embedding-001";
+  }
+}
+
+// src/semantic/indexer.ts
+import { readFileSync as readFileSync3, statSync } from "fs";
+import { relative as relative7 } from "path";
+import { minimatch as minimatch2 } from "minimatch";
+var MAX_FILE_SIZE3 = 1024 * 1024;
+async function getIndexStatus(workingDirectory) {
+  const config = getConfig();
+  const namespace = await getRepoNamespace(
+    workingDirectory,
+    config.resolvedVectorGateway.namespace
+  );
+  const isConfigured = !!config.resolvedVectorGateway.redisUrl;
+  if (!namespace) {
+    return {
+      namespace: "",
+      totalChunks: 0,
+      lastFullIndex: null,
+      lastIncrementalIndex: null,
+      isConfigured
+    };
+  }
+  try {
+    const db = getDb();
+    const status = await indexStatusQueries.get(db, namespace);
+    if (!status) {
+      return {
+        namespace,
+        totalChunks: 0,
+        lastFullIndex: null,
+        lastIncrementalIndex: null,
+        isConfigured
+      };
+    }
+    return {
+      namespace,
+      totalChunks: status.totalChunks ?? 0,
+      lastFullIndex: status.lastFullIndex ?? null,
+      lastIncrementalIndex: status.lastIncrementalIndex ?? null,
+      isConfigured
+    };
+  } catch {
+    return {
+      namespace,
+      totalChunks: 0,
+      lastFullIndex: null,
+      lastIncrementalIndex: null,
+      isConfigured
+    };
+  }
+}
+async function checkIndexExists(workingDirectory) {
+  const status = await getIndexStatus(workingDirectory);
+  return status.totalChunks > 0;
+}
+
+// src/tools/semantic-search.ts
+var semanticSearchInputSchema = z10.object({
+  query: z10.string().describe("Natural language search query describing what you want to find"),
+  topK: z10.number().optional().default(10).describe("Number of results to return (default: 10, max: 50)"),
+  filePattern: z10.string().optional().describe('Filter results by file glob pattern (e.g., "*.ts", "src/**/*.py")'),
+  language: z10.string().optional().describe('Filter by programming language (e.g., "typescript", "python")')
+});
+function createSemanticSearchTool(options) {
+  return tool9({
+    description: `Search the codebase using semantic similarity. This tool finds code by understanding its meaning, not just matching text.
+
+Use this tool when:
+- You need to understand how something works in the codebase
+- You're looking for code related to a concept (e.g., "authentication", "database queries")
+- You want to find implementations of features
+- The user asks "where is X?" or "how does Y work?"
+
+This tool requires the repository to be indexed first with 'sparkecoder index'.
+
+Returns matching code snippets with file paths, line numbers, and relevance scores.`,
+    inputSchema: semanticSearchInputSchema,
+    execute: async ({
+      query,
+      topK,
+      filePattern,
+      language
+    }) => {
+      const startTime = Date.now();
+      try {
+        const config = getConfig();
+        const namespace = await getRepoNamespace(
+          options.workingDirectory,
+          config.resolvedVectorGateway.namespace
+        );
+        if (!namespace) {
+          return {
+            success: false,
+            error: "Repository namespace not found. Ensure this is a git repository with a remote configured."
+          };
+        }
+        const client = getVectorClient();
+        if (!client) {
+          return {
+            success: false,
+            error: 'Vector Gateway not configured. Run "sparkecoder index --status" for setup instructions.'
+          };
+        }
+        try {
+          const limitedTopK = Math.min(Math.max(1, topK), 50);
+          const embeddingModel = getEmbeddingModel();
+          const result = await client.search.queryAndWait(query, {
+            namespace,
+            topK: limitedTopK * 2,
+            includeMetadata: true,
+            embeddingModel
+          });
+          const matches = [];
+          for (const match of result.matches) {
+            const metadata = match.metadata;
+            if (!metadata) continue;
+            const filePath = metadata.filePath;
+            const startLine = metadata.startLine;
+            const endLine = metadata.endLine;
+            const matchLanguage = metadata.language;
+            const symbolName = metadata.symbolName;
+            if (filePattern) {
+              const matchesPattern = minimatch3(filePath, filePattern, { dot: true });
+              if (!matchesPattern) continue;
+            }
+            if (language && matchLanguage !== language.toLowerCase()) {
+              continue;
+            }
+            const fullPath = join5(options.workingDirectory, filePath);
+            if (!existsSync11(fullPath)) {
+              continue;
+            }
+            let snippet = "";
+            try {
+              const content = readFileSync4(fullPath, "utf-8");
+              const lines = content.split("\n");
+              const snippetLines = lines.slice(
+                Math.max(0, startLine - 1),
+                Math.min(lines.length, endLine)
+              );
+              snippet = snippetLines.join("\n");
+              if (snippet.length > 500) {
+                snippet = snippet.slice(0, 500) + "\n... (truncated)";
+              }
+            } catch {
+            }
+            matches.push({
+              filePath,
+              startLine,
+              endLine,
+              score: match.score,
+              snippet,
+              symbolName,
+              language: matchLanguage
+            });
+            if (matches.length >= limitedTopK) {
+              break;
+            }
+          }
+          return {
+            success: true,
+            query,
+            matches,
+            totalMatches: matches.length,
+            duration: Date.now() - startTime
+          };
+        } finally {
+          await closeVectorClient();
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Semantic search failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  });
+}
+
 // src/tools/index.ts
-function createTools(options) {
-  return {
+async function createTools(options) {
+  const tools = {
     bash: createBashTool({
       workingDirectory: options.workingDirectory,
       sessionId: options.sessionId,
@@ -3026,6 +3289,20 @@ function createTools(options) {
       onProgress: options.onSearchProgress
     })
   };
+  if (options.enableSemanticSearch !== false) {
+    try {
+      if (isVectorGatewayConfigured()) {
+        const hasIndex = await checkIndexExists(options.workingDirectory);
+        if (hasIndex) {
+          tools.semantic_search = createSemanticSearchTool({
+            workingDirectory: options.workingDirectory
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return tools;
 }
 export {
   createBashTool,
@@ -3033,6 +3310,7 @@ export {
   createLoadSkillTool,
   createReadFileTool,
   createSearchTool,
+  createSemanticSearchTool,
   createTodoTool,
   createTools,
   createWriteFileTool