sparkecoder 0.1.3

package/dist/agent/index.js

@@ -0,0 +1,1979 @@
+// src/agent/index.ts
+import {
+  streamText,
+  generateText as generateText2,
+  tool as tool7,
+  stepCountIs
+} from "ai";
+import { gateway as gateway2 } from "@ai-sdk/gateway";
+import { z as z8 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+
+// 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 } 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" })
+});
+
+// src/db/index.ts
+var db = null;
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return db;
+}
+var sessionQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(sessions).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
+  },
+  list(limit = 50, offset = 0) {
+    return getDb().select().from(sessions).orderBy(desc(sessions.createdAt)).limit(limit).offset(offset).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(sessions).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
+    return result.changes > 0;
+  }
+};
+var messageQueries = {
+  /**
+   * Get the next sequence number for a session
+   */
+  getNextSequence(sessionId) {
+    const result = getDb().select({ maxSeq: sql`COALESCE(MAX(sequence), -1)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return (result?.maxSeq ?? -1) + 1;
+  },
+  /**
+   * Create a single message from a ModelMessage
+   */
+  create(sessionId, modelMessage) {
+    const id = nanoid();
+    const sequence = this.getNextSequence(sessionId);
+    const result = getDb().insert(messages).values({
+      id,
+      sessionId,
+      modelMessage,
+      sequence,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  /**
+   * Add multiple ModelMessages at once (from response.messages)
+   * Maintains insertion order via sequence numbers
+   */
+  addMany(sessionId, modelMessages) {
+    const results = [];
+    let sequence = this.getNextSequence(sessionId);
+    for (const msg of modelMessages) {
+      const id = nanoid();
+      const result = getDb().insert(messages).values({
+        id,
+        sessionId,
+        modelMessage: msg,
+        sequence,
+        createdAt: /* @__PURE__ */ new Date()
+      }).returning().get();
+      results.push(result);
+      sequence++;
+    }
+    return results;
+  },
+  /**
+   * Get all messages for a session as ModelMessage[]
+   * Ordered by sequence to maintain exact insertion order
+   */
+  getBySession(sessionId) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(messages.sequence).all();
+  },
+  /**
+   * Get ModelMessages directly (for passing to AI SDK)
+   */
+  getModelMessages(sessionId) {
+    const messages2 = this.getBySession(sessionId);
+    return messages2.map((m) => m.modelMessage);
+  },
+  getRecentBySession(sessionId, limit = 50) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all().reverse();
+  },
+  countBySession(sessionId) {
+    const result = getDb().select({ count: sql`count(*)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return result?.count ?? 0;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var toolExecutionQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(toolExecutions).values({
+      id,
+      ...data,
+      startedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.id, id)).get();
+  },
+  getByToolCallId(toolCallId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.toolCallId, toolCallId)).get();
+  },
+  getPendingApprovals(sessionId) {
+    return getDb().select().from(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        eq(toolExecutions.status, "pending"),
+        eq(toolExecutions.requiresApproval, true)
+      )
+    ).all();
+  },
+  approve(id) {
+    return getDb().update(toolExecutions).set({ status: "approved" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  reject(id) {
+    return getDb().update(toolExecutions).set({ status: "rejected" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  complete(id, output, error) {
+    return getDb().update(toolExecutions).set({
+      status: error ? "error" : "completed",
+      output,
+      error,
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+  }
+};
+var todoQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(todoItems).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  createMany(sessionId, items) {
+    const now = /* @__PURE__ */ new Date();
+    const values = items.map((item, index) => ({
+      id: nanoid(),
+      sessionId,
+      content: item.content,
+      order: item.order ?? index,
+      createdAt: now,
+      updatedAt: now
+    }));
+    return getDb().insert(todoItems).values(values).returning().all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
+    return result.changes > 0;
+  },
+  clearSession(sessionId) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var skillQueries = {
+  load(sessionId, skillName) {
+    const id = nanoid();
+    const result = getDb().insert(loadedSkills).values({
+      id,
+      sessionId,
+      skillName,
+      loadedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+  },
+  isLoaded(sessionId, skillName) {
+    const result = getDb().select().from(loadedSkills).where(
+      and(
+        eq(loadedSkills.sessionId, sessionId),
+        eq(loadedSkills.skillName, skillName)
+      )
+    ).get();
+    return !!result;
+  }
+};
+var terminalQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(terminals).values({
+      id,
+      ...data,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(terminals).where(eq(terminals.id, id)).get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(terminals).where(eq(terminals.sessionId, sessionId)).orderBy(desc(terminals.createdAt)).all();
+  },
+  getRunning(sessionId) {
+    return getDb().select().from(terminals).where(
+      and(
+        eq(terminals.sessionId, sessionId),
+        eq(terminals.status, "running")
+      )
+    ).all();
+  },
+  updateStatus(id, status, exitCode, error) {
+    return getDb().update(terminals).set({
+      status,
+      exitCode,
+      error,
+      stoppedAt: status !== "running" ? /* @__PURE__ */ new Date() : void 0
+    }).where(eq(terminals.id, id)).returning().get();
+  },
+  updatePid(id, pid) {
+    return getDb().update(terminals).set({ pid }).where(eq(terminals.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(terminals).where(eq(terminals.id, id)).run();
+    return result.changes > 0;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(terminals).where(eq(terminals.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+
+// src/config/index.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve, dirname } from "path";
+
+// src/config/types.ts
+import { z } from "zod";
+var ToolApprovalConfigSchema = z.object({
+  bash: z.boolean().optional().default(true),
+  write_file: z.boolean().optional().default(false),
+  read_file: z.boolean().optional().default(false),
+  load_skill: z.boolean().optional().default(false),
+  todo: z.boolean().optional().default(false)
+});
+var SkillMetadataSchema = z.object({
+  name: z.string(),
+  description: z.string()
+});
+var SessionConfigSchema = z.object({
+  toolApprovals: z.record(z.string(), z.boolean()).optional(),
+  approvalWebhook: z.string().url().optional(),
+  skillsDirectory: z.string().optional(),
+  maxContextChars: z.number().optional().default(2e5)
+});
+var SparkcoderConfigSchema = z.object({
+  // Default model to use (Vercel AI Gateway format)
+  defaultModel: z.string().default("anthropic/claude-opus-4-5"),
+  // Working directory for file operations
+  workingDirectory: z.string().optional(),
+  // Tool approval settings
+  toolApprovals: ToolApprovalConfigSchema.optional().default({}),
+  // Approval webhook URL (called when approval is needed)
+  approvalWebhook: z.string().url().optional(),
+  // Skills configuration
+  skills: z.object({
+    // Directory containing skill files
+    directory: z.string().optional().default("./skills"),
+    // Additional skill directories to include
+    additionalDirectories: z.array(z.string()).optional().default([])
+  }).optional().default({}),
+  // Context management
+  context: z.object({
+    // Maximum context size before summarization (in characters)
+    maxChars: z.number().optional().default(2e5),
+    // Enable automatic summarization
+    autoSummarize: z.boolean().optional().default(true),
+    // Number of recent messages to keep after summarization
+    keepRecentMessages: z.number().optional().default(10)
+  }).optional().default({}),
+  // Server configuration
+  server: z.object({
+    port: z.number().default(3141),
+    host: z.string().default("127.0.0.1")
+  }).default({ port: 3141, host: "127.0.0.1" }),
+  // Database path
+  databasePath: z.string().optional().default("./sparkecoder.db")
+});
+
+// src/config/index.ts
+var cachedConfig = null;
+function getConfig() {
+  if (!cachedConfig) {
+    throw new Error("Config not loaded. Call loadConfig first.");
+  }
+  return cachedConfig;
+}
+function requiresApproval(toolName, sessionConfig) {
+  const config = getConfig();
+  if (sessionConfig?.toolApprovals?.[toolName] !== void 0) {
+    return sessionConfig.toolApprovals[toolName];
+  }
+  const globalApprovals = config.toolApprovals;
+  if (globalApprovals[toolName] !== void 0) {
+    return globalApprovals[toolName];
+  }
+  if (toolName === "bash") {
+    return true;
+  }
+  return false;
+}
+
+// src/tools/bash.ts
+import { tool } from "ai";
+import { z as z2 } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/utils/truncate.ts
+var MAX_OUTPUT_CHARS = 1e4;
+function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
+  if (output.length <= maxChars) {
+    return output;
+  }
+  const halfMax = Math.floor(maxChars / 2);
+  const truncatedChars = output.length - maxChars;
+  return output.slice(0, halfMax) + `
+
+... [TRUNCATED: ${truncatedChars.toLocaleString()} characters omitted] ...
+
+` + output.slice(-halfMax);
+}
+function calculateContextSize(messages2) {
+  return messages2.reduce((total, msg) => {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return total + content.length;
+  }, 0);
+}
+
+// src/tools/bash.ts
+var execAsync = promisify(exec);
+var COMMAND_TIMEOUT = 6e4;
+var MAX_OUTPUT_CHARS2 = 1e4;
+var BLOCKED_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "mkfs",
+  "dd if=/dev/zero",
+  ":(){:|:&};:",
+  "chmod -R 777 /"
+];
+function isBlockedCommand(command) {
+  const normalizedCommand = command.toLowerCase().trim();
+  return BLOCKED_COMMANDS.some(
+    (blocked) => normalizedCommand.includes(blocked.toLowerCase())
+  );
+}
+var bashInputSchema = z2.object({
+  command: z2.string().describe("The bash command to execute. Can be a single command or a pipeline.")
+});
+function createBashTool(options) {
+  return tool({
+    description: `Execute a bash command in the terminal. The command runs in the working directory: ${options.workingDirectory}. 
+Use this for running shell commands, scripts, git operations, package managers (npm, pip, etc.), and other CLI tools.
+Long outputs will be automatically truncated. Commands have a 60 second timeout.
+IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar operations.`,
+    inputSchema: bashInputSchema,
+    execute: async ({ command }) => {
+      if (isBlockedCommand(command)) {
+        return {
+          success: false,
+          error: "This command is blocked for safety reasons.",
+          stdout: "",
+          stderr: "",
+          exitCode: 1
+        };
+      }
+      try {
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: options.workingDirectory,
+          timeout: COMMAND_TIMEOUT,
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB buffer
+          shell: "/bin/bash"
+        });
+        const truncatedStdout = truncateOutput(stdout, MAX_OUTPUT_CHARS2);
+        const truncatedStderr = truncateOutput(stderr, MAX_OUTPUT_CHARS2 / 2);
+        if (options.onOutput) {
+          options.onOutput(truncatedStdout);
+        }
+        return {
+          success: true,
+          stdout: truncatedStdout,
+          stderr: truncatedStderr,
+          exitCode: 0
+        };
+      } catch (error) {
+        const stdout = error.stdout ? truncateOutput(error.stdout, MAX_OUTPUT_CHARS2) : "";
+        const stderr = error.stderr ? truncateOutput(error.stderr, MAX_OUTPUT_CHARS2) : "";
+        if (options.onOutput) {
+          options.onOutput(stderr || error.message);
+        }
+        if (error.killed) {
+          return {
+            success: false,
+            error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
+            stdout,
+            stderr,
+            exitCode: 124
+            // Standard timeout exit code
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          stdout,
+          stderr,
+          exitCode: error.code ?? 1
+        };
+      }
+    }
+  });
+}
+
+// src/tools/read-file.ts
+import { tool as tool2 } from "ai";
+import { z as z3 } from "zod";
+import { readFile, stat } from "fs/promises";
+import { resolve as resolve2, relative, isAbsolute } from "path";
+import { existsSync as existsSync2 } from "fs";
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_OUTPUT_CHARS3 = 5e4;
+var readFileInputSchema = z3.object({
+  path: z3.string().describe("The path to the file to read. Can be relative to working directory or absolute."),
+  startLine: z3.number().optional().describe("Optional: Start reading from this line number (1-indexed)"),
+  endLine: z3.number().optional().describe("Optional: Stop reading at this line number (1-indexed, inclusive)")
+});
+function createReadFileTool(options) {
+  return tool2({
+    description: `Read the contents of a file. Provide a path relative to the working directory (${options.workingDirectory}) or an absolute path.
+Large files will be automatically truncated. Binary files are not supported.
+Use this to understand existing code, check file contents, or gather context.`,
+    inputSchema: readFileInputSchema,
+    execute: async ({ path, startLine, endLine }) => {
+      try {
+        const absolutePath = isAbsolute(path) ? path : resolve2(options.workingDirectory, path);
+        const relativePath = relative(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional.",
+            content: null
+          };
+        }
+        if (!existsSync2(absolutePath)) {
+          return {
+            success: false,
+            error: `File not found: ${path}`,
+            content: null
+          };
+        }
+        const stats = await stat(absolutePath);
+        if (stats.size > MAX_FILE_SIZE) {
+          return {
+            success: false,
+            error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB.`,
+            content: null
+          };
+        }
+        if (stats.isDirectory()) {
+          return {
+            success: false,
+            error: 'Path is a directory, not a file. Use bash with "ls" to list directory contents.',
+            content: null
+          };
+        }
+        let content = await readFile(absolutePath, "utf-8");
+        if (startLine !== void 0 || endLine !== void 0) {
+          const lines = content.split("\n");
+          const start = (startLine ?? 1) - 1;
+          const end = endLine ?? lines.length;
+          if (start < 0 || start >= lines.length) {
+            return {
+              success: false,
+              error: `Start line ${startLine} is out of range. File has ${lines.length} lines.`,
+              content: null
+            };
+          }
+          content = lines.slice(start, end).join("\n");
+          const lineNumbers = lines.slice(start, end).map((line, idx) => `${(start + idx + 1).toString().padStart(4)}: ${line}`).join("\n");
+          content = lineNumbers;
+        }
+        const truncatedContent = truncateOutput(content, MAX_OUTPUT_CHARS3);
+        const wasTruncated = truncatedContent.length < content.length;
+        return {
+          success: true,
+          path: absolutePath,
+          relativePath: relative(options.workingDirectory, absolutePath),
+          content: truncatedContent,
+          lineCount: content.split("\n").length,
+          wasTruncated,
+          sizeBytes: stats.size
+        };
+      } catch (error) {
+        if (error.code === "ERR_INVALID_ARG_VALUE" || error.message.includes("encoding")) {
+          return {
+            success: false,
+            error: "File appears to be binary and cannot be read as text.",
+            content: null
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          content: null
+        };
+      }
+    }
+  });
+}
+
+// src/tools/write-file.ts
+import { tool as tool3 } from "ai";
+import { z as z4 } from "zod";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { resolve as resolve3, relative as relative2, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var writeFileInputSchema = z4.object({
+  path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
+  mode: z4.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
+  content: z4.string().optional().describe('For "full" mode: The complete content to write to the file'),
+  old_string: z4.string().optional().describe('For "str_replace" mode: The exact string to find and replace'),
+  new_string: z4.string().optional().describe('For "str_replace" mode: The string to replace old_string with')
+});
+function createWriteFileTool(options) {
+  return tool3({
+    description: `Write content to a file. Supports two modes:
+1. "full" - Write the entire file content (creates new file or replaces existing)
+2. "str_replace" - Replace a specific string in an existing file (for precise edits)
+
+For str_replace mode:
+- Provide the exact string to find (old_string) and its replacement (new_string)
+- The old_string must match EXACTLY (including whitespace and indentation)
+- Only the first occurrence is replaced
+- Use this for surgical edits to existing code
+
+For full mode:
+- Provide the complete file content
+- Creates parent directories if they don't exist
+- Use this for new files or complete rewrites
+
+Working directory: ${options.workingDirectory}`,
+    inputSchema: writeFileInputSchema,
+    execute: async ({ path, mode, content, old_string, new_string }) => {
+      try {
+        const absolutePath = isAbsolute2(path) ? path : resolve3(options.workingDirectory, path);
+        const relativePath = relative2(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute2(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional."
+          };
+        }
+        if (mode === "full") {
+          if (content === void 0) {
+            return {
+              success: false,
+              error: 'Content is required for "full" mode'
+            };
+          }
+          const dir = dirname2(absolutePath);
+          if (!existsSync3(dir)) {
+            await mkdir(dir, { recursive: true });
+          }
+          const existed = existsSync3(absolutePath);
+          await writeFile(absolutePath, content, "utf-8");
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative2(options.workingDirectory, absolutePath),
+            mode: "full",
+            action: existed ? "replaced" : "created",
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            lineCount: content.split("\n").length
+          };
+        } else if (mode === "str_replace") {
+          if (old_string === void 0 || new_string === void 0) {
+            return {
+              success: false,
+              error: 'Both old_string and new_string are required for "str_replace" mode'
+            };
+          }
+          if (!existsSync3(absolutePath)) {
+            return {
+              success: false,
+              error: `File not found: ${path}. Use "full" mode to create new files.`
+            };
+          }
+          const currentContent = await readFile2(absolutePath, "utf-8");
+          if (!currentContent.includes(old_string)) {
+            const lines = currentContent.split("\n");
+            const preview = lines.slice(0, 20).join("\n");
+            return {
+              success: false,
+              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
+              hint: "Check for differences in indentation, line endings, or invisible characters.",
+              filePreview: lines.length > 20 ? `${preview}
+... (${lines.length - 20} more lines)` : preview
+            };
+          }
+          const occurrences = currentContent.split(old_string).length - 1;
+          if (occurrences > 1) {
+            return {
+              success: false,
+              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
+              hint: "Include surrounding lines or more specific content in old_string."
+            };
+          }
+          const newContent = currentContent.replace(old_string, new_string);
+          await writeFile(absolutePath, newContent, "utf-8");
+          const oldLines = old_string.split("\n").length;
+          const newLines = new_string.split("\n").length;
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative2(options.workingDirectory, absolutePath),
+            mode: "str_replace",
+            linesRemoved: oldLines,
+            linesAdded: newLines,
+            lineDelta: newLines - oldLines
+          };
+        }
+        return {
+          success: false,
+          error: `Invalid mode: ${mode}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// src/tools/todo.ts
+import { tool as tool4 } from "ai";
+import { z as z5 } from "zod";
+var todoInputSchema = z5.object({
+  action: z5.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
+  items: z5.array(
+    z5.object({
+      content: z5.string().describe("Description of the task"),
+      order: z5.number().optional().describe("Optional order/priority (lower = higher priority)")
+    })
+  ).optional().describe('For "add" action: Array of todo items to add'),
+  todoId: z5.string().optional().describe('For "mark" action: The ID of the todo item to update'),
+  status: z5.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item')
+});
+function createTodoTool(options) {
+  return tool4({
+    description: `Manage your task list for the current session. Use this to:
+- Break down complex tasks into smaller steps
+- Track progress on multi-step operations
+- Organize your work systematically
+
+Available actions:
+- "add": Add one or more new todo items to the list
+- "list": View all current todo items and their status
+- "mark": Update the status of a todo item (pending, in_progress, completed, cancelled)
+- "clear": Remove all todo items from the list
+
+Best practices:
+- Add todos before starting complex tasks
+- Mark items as "in_progress" when actively working on them
+- Update status as you complete each step`,
+    inputSchema: todoInputSchema,
+    execute: async ({ action, items, todoId, status }) => {
+      try {
+        switch (action) {
+          case "add": {
+            if (!items || items.length === 0) {
+              return {
+                success: false,
+                error: "No items provided. Include at least one todo item."
+              };
+            }
+            const created = todoQueries.createMany(options.sessionId, items);
+            return {
+              success: true,
+              action: "add",
+              itemsAdded: created.length,
+              items: created.map(formatTodoItem)
+            };
+          }
+          case "list": {
+            const todos = todoQueries.getBySession(options.sessionId);
+            const stats = {
+              total: todos.length,
+              pending: todos.filter((t) => t.status === "pending").length,
+              inProgress: todos.filter((t) => t.status === "in_progress").length,
+              completed: todos.filter((t) => t.status === "completed").length,
+              cancelled: todos.filter((t) => t.status === "cancelled").length
+            };
+            return {
+              success: true,
+              action: "list",
+              stats,
+              items: todos.map(formatTodoItem)
+            };
+          }
+          case "mark": {
+            if (!todoId) {
+              return {
+                success: false,
+                error: 'todoId is required for "mark" action'
+              };
+            }
+            if (!status) {
+              return {
+                success: false,
+                error: 'status is required for "mark" action'
+              };
+            }
+            const updated = todoQueries.updateStatus(todoId, status);
+            if (!updated) {
+              return {
+                success: false,
+                error: `Todo item not found: ${todoId}`
+              };
+            }
+            return {
+              success: true,
+              action: "mark",
+              item: formatTodoItem(updated)
+            };
+          }
+          case "clear": {
+            const count = todoQueries.clearSession(options.sessionId);
+            return {
+              success: true,
+              action: "clear",
+              itemsRemoved: count
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatTodoItem(item) {
+  return {
+    id: item.id,
+    content: item.content,
+    status: item.status,
+    order: item.order,
+    createdAt: item.createdAt.toISOString()
+  };
+}
+
+// src/tools/load-skill.ts
+import { tool as tool5 } from "ai";
+import { z as z6 } from "zod";
+
+// src/skills/index.ts
+import { readFile as readFile3, readdir } from "fs/promises";
+import { resolve as resolve4, basename, extname } from "path";
+import { existsSync as existsSync4 } from "fs";
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  try {
+    const lines = frontmatter.split("\n");
+    const data = {};
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        data[key] = value;
+      }
+    }
+    const metadata = SkillMetadataSchema.parse(data);
+    return { metadata, body: body.trim() };
+  } catch {
+    return null;
+  }
+}
+function getSkillNameFromPath(filePath) {
+  return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function loadSkillsFromDirectory(directory) {
+  if (!existsSync4(directory)) {
+    return [];
+  }
+  const skills = [];
+  const files = await readdir(directory);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = resolve4(directory, file);
+    const content = await readFile3(filePath, "utf-8");
+    const parsed = parseSkillFrontmatter(content);
+    if (parsed) {
+      skills.push({
+        name: parsed.metadata.name,
+        description: parsed.metadata.description,
+        filePath
+      });
+    } else {
+      const name = getSkillNameFromPath(filePath);
+      const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
+      skills.push({
+        name,
+        description: firstParagraph.replace(/^#\s*/, "").trim(),
+        filePath
+      });
+    }
+  }
+  return skills;
+}
+async function loadAllSkills(directories) {
+  const allSkills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const dir of directories) {
+    const skills = await loadSkillsFromDirectory(dir);
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  return allSkills;
+}
+async function loadSkillContent(skillName, directories) {
+  const allSkills = await loadAllSkills(directories);
+  const skill = allSkills.find(
+    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  );
+  if (!skill) {
+    return null;
+  }
+  const content = await readFile3(skill.filePath, "utf-8");
+  const parsed = parseSkillFrontmatter(content);
+  return {
+    ...skill,
+    content: parsed ? parsed.body : content
+  };
+}
+function formatSkillsForContext(skills) {
+  if (skills.length === 0) {
+    return "No skills available.";
+  }
+  const lines = ["Available skills (use load_skill tool to load into context):"];
+  for (const skill of skills) {
+    lines.push(`- ${skill.name}: ${skill.description}`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/load-skill.ts
+var loadSkillInputSchema = z6.object({
+  action: z6.enum(["list", "load"]).describe('Action to perform: "list" to see available skills, "load" to load a skill'),
+  skillName: z6.string().optional().describe('For "load" action: The name of the skill to load')
+});
+function createLoadSkillTool(options) {
+  return tool5({
+    description: `Load a skill document into the conversation context. Skills are specialized knowledge files that provide guidance on specific topics like debugging, code review, architecture patterns, etc.
+
+Available actions:
+- "list": Show all available skills with their descriptions
+- "load": Load a specific skill's full content into context
+
+Use this when you need specialized knowledge or guidance for a particular task.
+Once loaded, a skill's content will be available in the conversation context.`,
+    inputSchema: loadSkillInputSchema,
+    execute: async ({ action, skillName }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const skills = await loadAllSkills(options.skillsDirectories);
+            return {
+              success: true,
+              action: "list",
+              skillCount: skills.length,
+              skills: skills.map((s) => ({
+                name: s.name,
+                description: s.description
+              })),
+              formatted: formatSkillsForContext(skills)
+            };
+          }
+          case "load": {
+            if (!skillName) {
+              return {
+                success: false,
+                error: 'skillName is required for "load" action'
+              };
+            }
+            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+              return {
+                success: false,
+                error: `Skill "${skillName}" is already loaded in this session`
+              };
+            }
+            const skill = await loadSkillContent(skillName, options.skillsDirectories);
+            if (!skill) {
+              const allSkills = await loadAllSkills(options.skillsDirectories);
+              return {
+                success: false,
+                error: `Skill "${skillName}" not found`,
+                availableSkills: allSkills.map((s) => s.name)
+              };
+            }
+            skillQueries.load(options.sessionId, skillName);
+            return {
+              success: true,
+              action: "load",
+              skillName: skill.name,
+              description: skill.description,
+              content: skill.content,
+              contentLength: skill.content.length
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// src/tools/terminal.ts
+import { tool as tool6 } from "ai";
+import { z as z7 } from "zod";
+
+// src/terminal/manager.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var LogBuffer = class {
+  buffer = [];
+  maxSize;
+  totalBytes = 0;
+  maxBytes;
+  constructor(maxBytes = 50 * 1024) {
+    this.maxBytes = maxBytes;
+    this.maxSize = 1e3;
+  }
+  append(data) {
+    const lines = data.split("\n");
+    for (const line of lines) {
+      if (line) {
+        this.buffer.push(line);
+        this.totalBytes += line.length;
+      }
+    }
+    while (this.totalBytes > this.maxBytes && this.buffer.length > 1) {
+      const removed = this.buffer.shift();
+      if (removed) {
+        this.totalBytes -= removed.length;
+      }
+    }
+    while (this.buffer.length > this.maxSize) {
+      const removed = this.buffer.shift();
+      if (removed) {
+        this.totalBytes -= removed.length;
+      }
+    }
+  }
+  getAll() {
+    return this.buffer.join("\n");
+  }
+  getTail(lines) {
+    const start = Math.max(0, this.buffer.length - lines);
+    return this.buffer.slice(start).join("\n");
+  }
+  clear() {
+    this.buffer = [];
+    this.totalBytes = 0;
+  }
+  get lineCount() {
+    return this.buffer.length;
+  }
+};
+var TerminalManager = class _TerminalManager extends EventEmitter {
+  processes = /* @__PURE__ */ new Map();
+  static instance = null;
+  constructor() {
+    super();
+  }
+  static getInstance() {
+    if (!_TerminalManager.instance) {
+      _TerminalManager.instance = new _TerminalManager();
+    }
+    return _TerminalManager.instance;
+  }
+  /**
+   * Spawn a new background process
+   */
+  spawn(options) {
+    const { sessionId, command, cwd, name, env } = options;
+    const parts = this.parseCommand(command);
+    const executable = parts[0];
+    const args = parts.slice(1);
+    const terminal = terminalQueries.create({
+      sessionId,
+      name: name || null,
+      command,
+      cwd: cwd || process.cwd(),
+      status: "running"
+    });
+    const proc = spawn(executable, args, {
+      cwd: cwd || process.cwd(),
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+      detached: false
+    });
+    if (proc.pid) {
+      terminalQueries.updatePid(terminal.id, proc.pid);
+    }
+    const logs = new LogBuffer();
+    proc.stdout?.on("data", (data) => {
+      const text2 = data.toString();
+      logs.append(text2);
+      this.emit("stdout", { terminalId: terminal.id, data: text2 });
+    });
+    proc.stderr?.on("data", (data) => {
+      const text2 = data.toString();
+      logs.append(`[stderr] ${text2}`);
+      this.emit("stderr", { terminalId: terminal.id, data: text2 });
+    });
+    proc.on("exit", (code, signal) => {
+      const exitCode = code ?? (signal ? 128 : 0);
+      terminalQueries.updateStatus(terminal.id, "stopped", exitCode);
+      this.emit("exit", { terminalId: terminal.id, code: exitCode, signal });
+      const managed2 = this.processes.get(terminal.id);
+      if (managed2) {
+        managed2.terminal = { ...managed2.terminal, status: "stopped", exitCode };
+      }
+    });
+    proc.on("error", (err) => {
+      terminalQueries.updateStatus(terminal.id, "error", void 0, err.message);
+      this.emit("error", { terminalId: terminal.id, error: err.message });
+      const managed2 = this.processes.get(terminal.id);
+      if (managed2) {
+        managed2.terminal = { ...managed2.terminal, status: "error", error: err.message };
+      }
+    });
+    const managed = {
+      id: terminal.id,
+      process: proc,
+      logs,
+      terminal: { ...terminal, pid: proc.pid ?? null }
+    };
+    this.processes.set(terminal.id, managed);
+    return this.toTerminalInfo(managed.terminal);
+  }
+  /**
+   * Get logs from a terminal
+   */
+  getLogs(terminalId, tail) {
+    const managed = this.processes.get(terminalId);
+    if (!managed) {
+      return null;
+    }
+    return {
+      logs: tail ? managed.logs.getTail(tail) : managed.logs.getAll(),
+      lineCount: managed.logs.lineCount
+    };
+  }
+  /**
+   * Get terminal status
+   */
+  getStatus(terminalId) {
+    const managed = this.processes.get(terminalId);
+    if (managed) {
+      if (managed.process.exitCode !== null) {
+        managed.terminal = {
+          ...managed.terminal,
+          status: "stopped",
+          exitCode: managed.process.exitCode
+        };
+      }
+      return this.toTerminalInfo(managed.terminal);
+    }
+    const terminal = terminalQueries.getById(terminalId);
+    if (terminal) {
+      return this.toTerminalInfo(terminal);
+    }
+    return null;
+  }
+  /**
+   * Kill a terminal process
+   */
+  kill(terminalId, signal = "SIGTERM") {
+    const managed = this.processes.get(terminalId);
+    if (!managed) {
+      return false;
+    }
+    try {
+      managed.process.kill(signal);
+      return true;
+    } catch (err) {
+      console.error(`Failed to kill terminal ${terminalId}:`, err);
+      return false;
+    }
+  }
+  /**
+   * Write to a terminal's stdin
+   */
+  write(terminalId, input) {
+    const managed = this.processes.get(terminalId);
+    if (!managed || !managed.process.stdin) {
+      return false;
+    }
+    try {
+      managed.process.stdin.write(input);
+      return true;
+    } catch (err) {
+      console.error(`Failed to write to terminal ${terminalId}:`, err);
+      return false;
+    }
+  }
+  /**
+   * List all terminals for a session
+   */
+  list(sessionId) {
+    const terminals2 = terminalQueries.getBySession(sessionId);
+    return terminals2.map((t) => {
+      const managed = this.processes.get(t.id);
+      if (managed) {
+        return this.toTerminalInfo(managed.terminal);
+      }
+      return this.toTerminalInfo(t);
+    });
+  }
+  /**
+   * Get all running terminals for a session
+   */
+  getRunning(sessionId) {
+    return this.list(sessionId).filter((t) => t.status === "running");
+  }
+  /**
+   * Kill all terminals for a session (cleanup)
+   */
+  killAll(sessionId) {
+    let killed = 0;
+    for (const [id, managed] of this.processes) {
+      if (managed.terminal.sessionId === sessionId) {
+        if (this.kill(id)) {
+          killed++;
+        }
+      }
+    }
+    return killed;
+  }
+  /**
+   * Clean up stopped terminals from memory (keep DB records)
+   */
+  cleanup(sessionId) {
+    let cleaned = 0;
+    for (const [id, managed] of this.processes) {
+      if (sessionId && managed.terminal.sessionId !== sessionId) {
+        continue;
+      }
+      if (managed.terminal.status !== "running") {
+        this.processes.delete(id);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * Parse a command string into executable and arguments
+   */
+  parseCommand(command) {
+    const parts = [];
+    let current = "";
+    let inQuote = false;
+    let quoteChar = "";
+    for (const char of command) {
+      if ((char === '"' || char === "'") && !inQuote) {
+        inQuote = true;
+        quoteChar = char;
+      } else if (char === quoteChar && inQuote) {
+        inQuote = false;
+        quoteChar = "";
+      } else if (char === " " && !inQuote) {
+        if (current) {
+          parts.push(current);
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current) {
+      parts.push(current);
+    }
+    return parts.length > 0 ? parts : [command];
+  }
+  toTerminalInfo(terminal) {
+    return {
+      id: terminal.id,
+      name: terminal.name,
+      command: terminal.command,
+      cwd: terminal.cwd,
+      pid: terminal.pid,
+      status: terminal.status,
+      exitCode: terminal.exitCode,
+      error: terminal.error,
+      createdAt: terminal.createdAt,
+      stoppedAt: terminal.stoppedAt
+    };
+  }
+};
+function getTerminalManager() {
+  return TerminalManager.getInstance();
+}
+
+// src/tools/terminal.ts
+var TerminalInputSchema = z7.object({
+  action: z7.enum(["spawn", "logs", "status", "kill", "write", "list"]).describe(
+    "The action to perform: spawn (start process), logs (get output), status (check if running), kill (stop process), write (send stdin), list (show all)"
+  ),
+  // For spawn
+  command: z7.string().optional().describe('For spawn: The command to run (e.g., "npm run dev")'),
+  cwd: z7.string().optional().describe("For spawn: Working directory for the command"),
+  name: z7.string().optional().describe('For spawn: Optional friendly name (e.g., "dev-server")'),
+  // For logs, status, kill, write
+  terminalId: z7.string().optional().describe("For logs/status/kill/write: The terminal ID"),
+  tail: z7.number().optional().describe("For logs: Number of lines to return from the end"),
+  // For kill
+  signal: z7.enum(["SIGTERM", "SIGKILL"]).optional().describe("For kill: Signal to send (default: SIGTERM)"),
+  // For write
+  input: z7.string().optional().describe("For write: The input to send to stdin")
+});
+function createTerminalTool(options) {
+  const { sessionId, workingDirectory } = options;
+  return tool6({
+    description: `Manage background terminal processes. Use this for long-running commands like dev servers, watchers, or any process that shouldn't block.
+
+Actions:
+- spawn: Start a new background process. Requires 'command'. Returns terminal ID.
+- logs: Get output from a terminal. Requires 'terminalId'. Optional 'tail' for recent lines.
+- status: Check if a terminal is still running. Requires 'terminalId'.
+- kill: Stop a terminal process. Requires 'terminalId'. Optional 'signal'.
+- write: Send input to a terminal's stdin. Requires 'terminalId' and 'input'.
+- list: Show all terminals for this session. No other params needed.
+
+Example workflow:
+1. spawn with command="npm run dev", name="dev-server" \u2192 { id: "abc123", status: "running" }
+2. logs with terminalId="abc123", tail=10 \u2192 "Ready on http://localhost:3000"
+3. kill with terminalId="abc123" \u2192 { success: true }`,
+    inputSchema: TerminalInputSchema,
+    execute: async (input) => {
+      const manager = getTerminalManager();
+      switch (input.action) {
+        case "spawn": {
+          if (!input.command) {
+            return { success: false, error: 'spawn requires a "command" parameter' };
+          }
+          const terminal = manager.spawn({
+            sessionId,
+            command: input.command,
+            cwd: input.cwd || workingDirectory,
+            name: input.name
+          });
+          return {
+            success: true,
+            terminal: formatTerminal(terminal),
+            message: `Started "${input.command}" with terminal ID: ${terminal.id}`
+          };
+        }
+        case "logs": {
+          if (!input.terminalId) {
+            return { success: false, error: 'logs requires a "terminalId" parameter' };
+          }
+          const result = manager.getLogs(input.terminalId, input.tail);
+          if (!result) {
+            return {
+              success: false,
+              error: `Terminal not found: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            terminalId: input.terminalId,
+            logs: result.logs,
+            lineCount: result.lineCount
+          };
+        }
+        case "status": {
+          if (!input.terminalId) {
+            return { success: false, error: 'status requires a "terminalId" parameter' };
+          }
+          const status = manager.getStatus(input.terminalId);
+          if (!status) {
+            return {
+              success: false,
+              error: `Terminal not found: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            terminal: formatTerminal(status)
+          };
+        }
+        case "kill": {
+          if (!input.terminalId) {
+            return { success: false, error: 'kill requires a "terminalId" parameter' };
+          }
+          const success = manager.kill(input.terminalId, input.signal);
+          if (!success) {
+            return {
+              success: false,
+              error: `Failed to kill terminal: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            message: `Sent ${input.signal || "SIGTERM"} to terminal ${input.terminalId}`
+          };
+        }
+        case "write": {
+          if (!input.terminalId) {
+            return { success: false, error: 'write requires a "terminalId" parameter' };
+          }
+          if (!input.input) {
+            return { success: false, error: 'write requires an "input" parameter' };
+          }
+          const success = manager.write(input.terminalId, input.input);
+          if (!success) {
+            return {
+              success: false,
+              error: `Failed to write to terminal: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            message: `Sent input to terminal ${input.terminalId}`
+          };
+        }
+        case "list": {
+          const terminals2 = manager.list(sessionId);
+          return {
+            success: true,
+            terminals: terminals2.map(formatTerminal),
+            count: terminals2.length,
+            running: terminals2.filter((t) => t.status === "running").length
+          };
+        }
+        default:
+          return { success: false, error: `Unknown action: ${input.action}` };
+      }
+    }
+  });
+}
+function formatTerminal(t) {
+  return {
+    id: t.id,
+    name: t.name,
+    command: t.command,
+    cwd: t.cwd,
+    pid: t.pid,
+    status: t.status,
+    exitCode: t.exitCode,
+    error: t.error,
+    createdAt: t.createdAt.toISOString(),
+    stoppedAt: t.stoppedAt?.toISOString() || null
+  };
+}
+
+// src/tools/index.ts
+function createTools(options) {
+  return {
+    bash: createBashTool({
+      workingDirectory: options.workingDirectory,
+      onOutput: options.onBashOutput
+    }),
+    read_file: createReadFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    write_file: createWriteFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    todo: createTodoTool({
+      sessionId: options.sessionId
+    }),
+    load_skill: createLoadSkillTool({
+      sessionId: options.sessionId,
+      skillsDirectories: options.skillsDirectories
+    }),
+    terminal: createTerminalTool({
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory
+    })
+  };
+}
+
+// src/agent/context.ts
+import { generateText } from "ai";
+import { gateway } from "@ai-sdk/gateway";
+
+// src/agent/prompts.ts
+async function buildSystemPrompt(options) {
+  const { workingDirectory, skillsDirectories, sessionId, customInstructions } = options;
+  const skills = await loadAllSkills(skillsDirectories);
+  const skillsContext = formatSkillsForContext(skills);
+  const todos = todoQueries.getBySession(sessionId);
+  const todosContext = formatTodosForContext(todos);
+  const systemPrompt = `You are Sparkecoder, an expert AI coding assistant. You help developers write, debug, and improve code.
+
+## Working Directory
+You are working in: ${workingDirectory}
+
+## Core Capabilities
+You have access to powerful tools for:
+- **bash**: Execute shell commands, run scripts, install packages, use git
+- **read_file**: Read file contents to understand code and context
+- **write_file**: Create new files or edit existing ones (supports targeted string replacement)
+- **todo**: Manage your task list to track progress on complex operations
+- **load_skill**: Load specialized knowledge documents for specific tasks
+
+## Guidelines
+
+### Code Quality
+- Write clean, maintainable, well-documented code
+- Follow existing code style and conventions in the project
+- Use meaningful variable and function names
+- Add comments for complex logic
+
+### Problem Solving
+- Before making changes, understand the existing code structure
+- Break complex tasks into smaller, manageable steps using the todo tool
+- Test changes when possible using the bash tool
+- Handle errors gracefully and provide helpful error messages
+
+### File Operations
+- Use \`read_file\` to understand code before modifying
+- Use \`write_file\` with mode "str_replace" for targeted edits to existing files
+- Use \`write_file\` with mode "full" only for new files or complete rewrites
+- Always verify changes by reading files after modifications
+
+### Communication
+- Explain your reasoning and approach
+- Be concise but thorough
+- Ask clarifying questions when requirements are ambiguous
+- Report progress on multi-step tasks
+
+## Skills
+${skillsContext}
+
+## Current Task List
+${todosContext}
+
+${customInstructions ? `## Custom Instructions
+${customInstructions}` : ""}
+
+Remember: You are a helpful, capable coding assistant. Take initiative, be thorough, and deliver high-quality results.`;
+  return systemPrompt;
+}
+function formatTodosForContext(todos) {
+  if (todos.length === 0) {
+    return "No active tasks. Use the todo tool to create a plan for complex operations.";
+  }
+  const statusEmoji = {
+    pending: "\u2B1C",
+    in_progress: "\u{1F504}",
+    completed: "\u2705",
+    cancelled: "\u274C"
+  };
+  const lines = ["Current tasks:"];
+  for (const todo of todos) {
+    const emoji = statusEmoji[todo.status] || "\u2022";
+    lines.push(`${emoji} [${todo.id}] ${todo.content}`);
+  }
+  return lines.join("\n");
+}
+function createSummaryPrompt(conversationHistory) {
+  return `Please provide a concise summary of the following conversation history. Focus on:
+1. The main task or goal being worked on
+2. Key decisions made
+3. Important code changes or file operations performed
+4. Current state and any pending actions
+
+Keep the summary under 2000 characters while preserving essential context for continuing the work.
+
+Conversation to summarize:
+${conversationHistory}
+
+Summary:`;
+}
+
+// src/agent/context.ts
+var ContextManager = class {
+  sessionId;
+  maxContextChars;
+  keepRecentMessages;
+  autoSummarize;
+  summary = null;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.maxContextChars = options.maxContextChars;
+    this.keepRecentMessages = options.keepRecentMessages;
+    this.autoSummarize = options.autoSummarize;
+  }
+  /**
+   * Get messages for the current context
+   * Returns ModelMessage[] that can be passed directly to streamText/generateText
+   */
+  async getMessages() {
+    let modelMessages = messageQueries.getModelMessages(this.sessionId);
+    const contextSize = calculateContextSize(modelMessages);
+    if (this.autoSummarize && contextSize > this.maxContextChars) {
+      modelMessages = await this.summarizeContext(modelMessages);
+    }
+    if (this.summary) {
+      modelMessages = [
+        {
+          role: "system",
+          content: `[Previous conversation summary]
+${this.summary}`
+        },
+        ...modelMessages
+      ];
+    }
+    return modelMessages;
+  }
+  /**
+   * Summarize older messages to reduce context size
+   */
+  async summarizeContext(messages2) {
+    if (messages2.length <= this.keepRecentMessages) {
+      return messages2;
+    }
+    const splitIndex = messages2.length - this.keepRecentMessages;
+    const oldMessages = messages2.slice(0, splitIndex);
+    const recentMessages = messages2.slice(splitIndex);
+    const historyText = oldMessages.map((msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return `[${msg.role}]: ${content}`;
+    }).join("\n\n");
+    try {
+      const config = getConfig();
+      const summaryPrompt = createSummaryPrompt(historyText);
+      const result = await generateText({
+        model: gateway(config.defaultModel),
+        prompt: summaryPrompt
+      });
+      this.summary = result.text;
+      console.log(`[Context] Summarized ${oldMessages.length} messages into ${this.summary.length} chars`);
+      return recentMessages;
+    } catch (error) {
+      console.error("[Context] Failed to summarize:", error);
+      return recentMessages;
+    }
+  }
+  /**
+   * Add a user message to the context
+   */
+  addUserMessage(text2) {
+    const userMessage = {
+      role: "user",
+      content: text2
+    };
+    messageQueries.create(this.sessionId, userMessage);
+  }
+  /**
+   * Add response messages from AI SDK directly
+   * This is the preferred method - use result.response.messages from streamText/generateText
+   */
+  addResponseMessages(messages2) {
+    messageQueries.addMany(this.sessionId, messages2);
+  }
+  /**
+   * Get current context statistics
+   */
+  getStats() {
+    const messages2 = messageQueries.getModelMessages(this.sessionId);
+    return {
+      messageCount: messages2.length,
+      contextChars: calculateContextSize(messages2),
+      hasSummary: this.summary !== null
+    };
+  }
+  /**
+   * Clear all messages in the context
+   */
+  clear() {
+    messageQueries.deleteBySession(this.sessionId);
+    this.summary = null;
+  }
+};
+
+// src/agent/index.ts
+var approvalResolvers = /* @__PURE__ */ new Map();
+var Agent = class _Agent {
+  session;
+  context;
+  tools;
+  pendingApprovals = /* @__PURE__ */ new Map();
+  constructor(session, context, tools) {
+    this.session = session;
+    this.context = context;
+    this.tools = tools;
+  }
+  /**
+   * Create or resume an agent session
+   */
+  static async create(options = {}) {
+    const config = getConfig();
+    let session;
+    if (options.sessionId) {
+      const existing = sessionQueries.getById(options.sessionId);
+      if (!existing) {
+        throw new Error(`Session not found: ${options.sessionId}`);
+      }
+      session = existing;
+    } else {
+      session = sessionQueries.create({
+        name: options.name,
+        workingDirectory: options.workingDirectory || config.resolvedWorkingDirectory,
+        model: options.model || config.defaultModel,
+        config: options.sessionConfig
+      });
+    }
+    const context = new ContextManager({
+      sessionId: session.id,
+      maxContextChars: config.context?.maxChars || 2e5,
+      keepRecentMessages: config.context?.keepRecentMessages || 10,
+      autoSummarize: config.context?.autoSummarize ?? true
+    });
+    const tools = createTools({
+      sessionId: session.id,
+      workingDirectory: session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories
+    });
+    return new _Agent(session, context, tools);
+  }
+  /**
+   * Get the session ID
+   */
+  get sessionId() {
+    return this.session.id;
+  }
+  /**
+   * Get session details
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Run the agent with a prompt (streaming)
+   */
+  async stream(options) {
+    const config = getConfig();
+    this.context.addUserMessage(options.prompt);
+    sessionQueries.updateStatus(this.session.id, "active");
+    const systemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id
+    });
+    const messages2 = await this.context.getMessages();
+    const wrappedTools = this.wrapToolsWithApproval(options);
+    const stream = streamText({
+      model: gateway2(this.session.model),
+      system: systemPrompt,
+      messages: messages2,
+      tools: wrappedTools,
+      stopWhen: stepCountIs(20),
+      onStepFinish: async (step) => {
+        options.onStepFinish?.(step);
+      }
+    });
+    const saveResponseMessages = async () => {
+      const result = await stream;
+      const response = await result.response;
+      const responseMessages = response.messages;
+      this.context.addResponseMessages(responseMessages);
+    };
+    return {
+      sessionId: this.session.id,
+      stream,
+      waitForApprovals: () => this.waitForApprovals(),
+      saveResponseMessages
+    };
+  }
+  /**
+   * Run the agent with a prompt (non-streaming)
+   */
+  async run(options) {
+    const config = getConfig();
+    this.context.addUserMessage(options.prompt);
+    const systemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id
+    });
+    const messages2 = await this.context.getMessages();
+    const wrappedTools = this.wrapToolsWithApproval(options);
+    const result = await generateText2({
+      model: gateway2(this.session.model),
+      system: systemPrompt,
+      messages: messages2,
+      tools: wrappedTools,
+      stopWhen: stepCountIs(20)
+    });
+    const responseMessages = result.response.messages;
+    this.context.addResponseMessages(responseMessages);
+    return {
+      text: result.text,
+      steps: result.steps
+    };
+  }
+  /**
+   * Wrap tools to add approval checking
+   */
+  wrapToolsWithApproval(options) {
+    const sessionConfig = this.session.config;
+    const wrappedTools = {};
+    for (const [name, originalTool] of Object.entries(this.tools)) {
+      const needsApproval = requiresApproval(name, sessionConfig ?? void 0);
+      if (!needsApproval) {
+        wrappedTools[name] = originalTool;
+        continue;
+      }
+      wrappedTools[name] = tool7({
+        description: originalTool.description || "",
+        inputSchema: originalTool.inputSchema || z8.object({}),
+        execute: async (input, toolOptions) => {
+          const toolCallId = toolOptions.toolCallId || nanoid2();
+          const execution = toolExecutionQueries.create({
+            sessionId: this.session.id,
+            toolName: name,
+            toolCallId,
+            input,
+            requiresApproval: true,
+            status: "pending"
+          });
+          this.pendingApprovals.set(toolCallId, execution);
+          options.onApprovalRequired?.(execution);
+          sessionQueries.updateStatus(this.session.id, "waiting");
+          const approved = await new Promise((resolve5) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve5, sessionId: this.session.id });
+          });
+          const resolverData = approvalResolvers.get(toolCallId);
+          approvalResolvers.delete(toolCallId);
+          this.pendingApprovals.delete(toolCallId);
+          if (!approved) {
+            const reason = resolverData?.reason || "User rejected the tool execution";
+            toolExecutionQueries.reject(execution.id);
+            sessionQueries.updateStatus(this.session.id, "active");
+            return {
+              status: "rejected",
+              toolCallId,
+              rejected: true,
+              reason,
+              message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
+            };
+          }
+          toolExecutionQueries.approve(execution.id);
+          sessionQueries.updateStatus(this.session.id, "active");
+          try {
+            const result = await originalTool.execute(input, toolOptions);
+            toolExecutionQueries.complete(execution.id, result);
+            return result;
+          } catch (error) {
+            toolExecutionQueries.complete(execution.id, null, error.message);
+            throw error;
+          }
+        }
+      });
+    }
+    return wrappedTools;
+  }
+  /**
+   * Wait for all pending approvals
+   */
+  async waitForApprovals() {
+    return Array.from(this.pendingApprovals.values());
+  }
+  /**
+   * Approve a pending tool execution
+   */
+  async approve(toolCallId) {
+    const resolver = approvalResolvers.get(toolCallId);
+    if (resolver) {
+      resolver.resolve(true);
+      return { approved: true };
+    }
+    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
+    if (!execution) {
+      throw new Error(`No pending approval for tool call: ${toolCallId}`);
+    }
+    toolExecutionQueries.approve(execution.id);
+    return { approved: true };
+  }
+  /**
+   * Reject a pending tool execution
+   */
+  reject(toolCallId, reason) {
+    const resolver = approvalResolvers.get(toolCallId);
+    if (resolver) {
+      resolver.reason = reason;
+      resolver.resolve(false);
+      return { rejected: true };
+    }
+    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
+    if (!execution) {
+      throw new Error(`No pending approval for tool call: ${toolCallId}`);
+    }
+    toolExecutionQueries.reject(execution.id);
+    return { rejected: true };
+  }
+  /**
+   * Get pending approvals
+   */
+  getPendingApprovals() {
+    return toolExecutionQueries.getPendingApprovals(this.session.id);
+  }
+  /**
+   * Get context statistics
+   */
+  getContextStats() {
+    return this.context.getStats();
+  }
+  /**
+   * Clear conversation context (start fresh)
+   */
+  clearContext() {
+    this.context.clear();
+  }
+};
+export {
+  Agent,
+  ContextManager,
+  buildSystemPrompt
+};
+//# sourceMappingURL=index.js.map