sparkecoder 0.1.82 → 0.1.83

package/dist/skills/default/browser.md

@@ -110,6 +110,36 @@ agent-browser wait --url "**/dashboard"    # Wait for URL pattern
 agent-browser wait 2000                    # Wait milliseconds
 ```
 
+### Video Recording
+Record browser actions to a WebM video file. Useful for demos, bug reproductions, or proof of work.
+
+```bash
+mkdir -p ".sparkecode-artifacts/recordings"
+
+# Start recording (from current page — preserves login state)
+agent-browser record start ".sparkecode-artifacts/recordings/demo.webm"
+
+# Do your interactions...
+agent-browser click @e3
+agent-browser fill @e4 "test@example.com"
+agent-browser click @e5
+
+# Stop and save
+agent-browser record stop
+```
+
+After recording, upload the video to get a shareable URL:
+```
+upload_file({ path: ".sparkecode-artifacts/recordings/demo.webm", name: "demo.webm" })
+```
+
+You can also restart recording into a new file without closing the browser:
+```bash
+agent-browser record restart ".sparkecode-artifacts/recordings/take2.webm"
+```
+
+**Note:** In task mode, browser sessions are also automatically recorded in the background. The MP4 recording is uploaded when the task completes and appears in the `GET /tasks/:id` response as `browserRecordings` and in the `task.completed` webhook as `browserRecordingUrls`. You do NOT need to manually record in task mode — it happens for free.
+
 ### Sessions
 ```bash
 agent-browser sessions                     # List active sessions

package/dist/tools/index.d.ts

@@ -80,15 +80,18 @@ declare function createReadFileTool(options: ReadFileToolOptions): ai.Tool<{
 
 interface TodoToolOptions {
     sessionId: string;
+    workingDirectory: string;
 }
 declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
-    action: "add" | "list" | "mark" | "clear";
+    action: "add" | "list" | "mark" | "clear" | "save_plan" | "list_plans" | "get_plan" | "delete_plan";
     status?: "completed" | "pending" | "in_progress" | "cancelled" | undefined;
     items?: {
         content: string;
         order?: number | undefined;
     }[] | undefined;
     todoId?: string | undefined;
+    planName?: string | undefined;
+    planContent?: string | undefined;
 }, {
     success: boolean;
     action: string;
@@ -103,6 +106,14 @@ declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
     stats?: undefined;
     item?: undefined;
     itemsRemoved?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
     error?: undefined;
 } | {
     success: boolean;
@@ -124,6 +135,14 @@ declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
     itemsAdded?: undefined;
     item?: undefined;
     itemsRemoved?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
     error?: undefined;
 } | {
     success: boolean;
@@ -139,6 +158,14 @@ declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
     items?: undefined;
     stats?: undefined;
     itemsRemoved?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
     error?: undefined;
 } | {
     success: boolean;
@@ -148,6 +175,87 @@ declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
     items?: undefined;
     stats?: undefined;
     item?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    action: string;
+    planName: string;
+    filename: string;
+    path: string;
+    sizeChars: number;
+    itemsAdded?: undefined;
+    items?: undefined;
+    stats?: undefined;
+    item?: undefined;
+    itemsRemoved?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    action: string;
+    plans: {
+        name: string;
+        title: string;
+        filename: string;
+        sizeChars: number;
+    }[];
+    count: number;
+    itemsAdded?: undefined;
+    items?: undefined;
+    stats?: undefined;
+    item?: undefined;
+    itemsRemoved?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    content?: undefined;
+    deleted?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    action: string;
+    planName: string;
+    content: string;
+    sizeChars: number;
+    itemsAdded?: undefined;
+    items?: undefined;
+    stats?: undefined;
+    item?: undefined;
+    itemsRemoved?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    deleted?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    action: string;
+    planName: string;
+    deleted: boolean;
+    itemsAdded?: undefined;
+    items?: undefined;
+    stats?: undefined;
+    item?: undefined;
+    itemsRemoved?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
     error?: undefined;
 } | {
     success: boolean;
@@ -158,6 +266,14 @@ declare function createTodoTool(options: TodoToolOptions): ai.Tool<{
     stats?: undefined;
     item?: undefined;
     itemsRemoved?: undefined;
+    planName?: undefined;
+    filename?: undefined;
+    path?: undefined;
+    sizeChars?: undefined;
+    plans?: undefined;
+    count?: undefined;
+    content?: undefined;
+    deleted?: undefined;
 }>;
 
 interface LoadSkillToolOptions {

package/dist/tools/index.js

@@ -848,7 +848,7 @@ var init_client = __esm({
 });
 
 // src/semantic/indexer.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync5, statSync } from "fs";
 import { relative as relative6 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 async function getIndexStatus(workingDirectory) {
@@ -933,8 +933,8 @@ __export(semantic_search_exports, {
 });
 import { tool as tool8 } from "ai";
 import { z as z9 } from "zod";
-import { existsSync as existsSync12, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 function createSemanticSearchTool(options) {
   return tool8({
@@ -1001,13 +1001,13 @@ Returns matching code snippets with file paths, line numbers, and relevance scor
             if (language && matchLanguage !== language.toLowerCase()) {
               continue;
             }
-            const fullPath = join5(options.workingDirectory, filePath);
-            if (!existsSync12(fullPath)) {
+            const fullPath = join6(options.workingDirectory, filePath);
+            if (!existsSync13(fullPath)) {
               continue;
             }
             let snippet = "";
             try {
-              const content = readFileSync5(fullPath, "utf-8");
+              const content = readFileSync6(fullPath, "utf-8");
               const lines = content.split("\n");
               const snippetLines = lines.slice(
                 Math.max(0, startLine - 1),
@@ -2729,8 +2729,34 @@ Working directory: ${options.workingDirectory}`,
 init_db();
 import { tool as tool4 } from "ai";
 import { z as z5 } from "zod";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync, unlinkSync, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
+function getPlansDir(workingDirectory, sessionId) {
+  return join4(workingDirectory, ".sparkecoder", "plans", sessionId);
+}
+function ensurePlansDir(workingDirectory, sessionId) {
+  const dir = getPlansDir(workingDirectory, sessionId);
+  if (!existsSync9(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  const gitignorePath = join4(workingDirectory, ".gitignore");
+  if (existsSync9(gitignorePath)) {
+    try {
+      const content = readFileSync3(gitignorePath, "utf-8");
+      if (!content.includes(".sparkecoder")) {
+        appendFileSync(gitignorePath, "\n.sparkecoder/\n");
+      }
+    } catch {
+    }
+  }
+  return dir;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "plan";
+}
 var todoInputSchema = z5.object({
-  action: z5.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
+  action: z5.enum(["add", "list", "mark", "clear", "save_plan", "list_plans", "get_plan", "delete_plan"]).describe("The action to perform"),
   items: z5.array(
     z5.object({
       content: z5.string().describe("Description of the task"),
@@ -2738,27 +2764,67 @@ var todoInputSchema = z5.object({
     })
   ).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')
+  status: z5.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item'),
+  planName: z5.string().optional().describe('For plan actions: Name of the plan (e.g. "auth-system", "db-migration")'),
+  planContent: z5.string().optional().describe('For "save_plan": Full plan content as markdown with hierarchical tasks using checkboxes')
 });
 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
+    description: `Manage your task list and persistent plans for the current session.
 
-Available actions:
+## Todo Actions (for tracking current work)
 - "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`,
+## Plan Actions (for complex, multi-phase work)
+- "save_plan": Create or update a named plan \u2014 a persistent markdown document with hierarchical tasks, subtasks, and notes. Plans survive context compaction and are always available.
+- "list_plans": List all plans for this session
+- "get_plan": Read a specific plan by name
+- "delete_plan": Remove a plan
+
+## Plans vs Todos
+- **Plans** are the big picture \u2014 the full spec with phases, subtasks, notes, and decisions. They persist on disk and are always injected into your context, even after old messages are summarized.
+- **Todos** are your current focus \u2014 the immediate steps you're working on right now.
+
+## Workflow for complex tasks
+1. Create a plan with phases and subtasks (save_plan)
+2. Create todos from the first uncompleted phase (add)
+3. Work through the todos, marking them as you go
+4. When all current todos are done, update the plan (mark completed sections with [x]) and save it
+5. Create new todos from the next uncompleted phase
+6. Repeat until the plan is fully complete
+
+## Plan format
+Plans should be markdown with this structure:
+\`\`\`markdown
+# Plan: [Title]
+
+## Overview
+[What we're doing and why]
+
+## Phase 1: [Name] [completed]
+- [x] Task 1
+- [x] Task 2
+
+## Phase 2: [Name] [in_progress]
+- [x] Subtask 2.1
+- [ ] Subtask 2.2
+  - [ ] Sub-subtask 2.2.1
+  - [ ] Sub-subtask 2.2.2
+- [ ] Subtask 2.3
+
+## Phase 3: [Name] [pending]
+- [ ] Task 1
+- [ ] Task 2
+
+## Notes
+- Key decisions and context to preserve
+- Important file paths discovered
+\`\`\``,
     inputSchema: todoInputSchema,
-    execute: async ({ action, items, todoId, status }) => {
+    execute: async ({ action, items, todoId, status, planName, planContent }) => {
       try {
         switch (action) {
           case "add": {
@@ -2826,6 +2892,81 @@ Best practices:
               itemsRemoved: count
             };
           }
+          // ── Plan actions ─────────────────────────────────────────
+          case "save_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "save_plan"' };
+            }
+            if (!planContent) {
+              return { success: false, error: 'planContent is required for "save_plan"' };
+            }
+            const dir = ensurePlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            await writeFile4(filePath, planContent, "utf-8");
+            return {
+              success: true,
+              action: "save_plan",
+              planName,
+              filename,
+              path: filePath,
+              sizeChars: planContent.length
+            };
+          }
+          case "list_plans": {
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            if (!existsSync9(dir)) {
+              return { success: true, action: "list_plans", plans: [], count: 0 };
+            }
+            const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+            const plans = [];
+            for (const f of files) {
+              try {
+                const content = await readFile6(join4(dir, f), "utf-8");
+                const titleMatch = content.match(/^#\s+(?:Plan:\s*)?(.+)/m);
+                plans.push({
+                  name: f.replace(/\.md$/, ""),
+                  title: titleMatch?.[1]?.trim() || f.replace(/\.md$/, ""),
+                  filename: f,
+                  sizeChars: content.length
+                });
+              } catch {
+              }
+            }
+            return { success: true, action: "list_plans", plans, count: plans.length };
+          }
+          case "get_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "get_plan"' };
+            }
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            if (!existsSync9(filePath)) {
+              return { success: false, error: `Plan not found: "${planName}" (looked for ${filename})` };
+            }
+            const content = await readFile6(filePath, "utf-8");
+            return {
+              success: true,
+              action: "get_plan",
+              planName,
+              content,
+              sizeChars: content.length
+            };
+          }
+          case "delete_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "delete_plan"' };
+            }
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            if (!existsSync9(filePath)) {
+              return { success: false, error: `Plan not found: "${planName}"` };
+            }
+            unlinkSync(filePath);
+            return { success: true, action: "delete_plan", planName, deleted: true };
+          }
           default:
             return {
               success: false,
@@ -2857,9 +2998,9 @@ import { z as z6 } from "zod";
 
 // src/skills/index.ts
 init_types();
-import { readFile as readFile6, readdir } from "fs/promises";
+import { readFile as readFile7, readdir } from "fs/promises";
 import { resolve as resolve6, basename, extname as extname4, relative as relative4 } from "path";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { minimatch } from "minimatch";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -2937,7 +3078,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     defaultLoadType = "on_demand",
     forceAlwaysApply = false
   } = options;
-  if (!existsSync9(directory)) {
+  if (!existsSync10(directory)) {
     return [];
   }
   const skills = [];
@@ -2947,7 +3088,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     let fileName;
     if (entry.isDirectory()) {
       const skillMdPath = resolve6(directory, entry.name, "SKILL.md");
-      if (existsSync9(skillMdPath)) {
+      if (existsSync10(skillMdPath)) {
         filePath = skillMdPath;
         fileName = entry.name;
       } else {
@@ -2959,7 +3100,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     } else {
       continue;
     }
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       const alwaysApply = forceAlwaysApply || parsed.metadata.alwaysApply;
@@ -3013,7 +3154,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile6(skill.filePath, "utf-8");
+  const content = await readFile7(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -3118,7 +3259,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
 import { tool as tool6 } from "ai";
 import { z as z7 } from "zod";
 import { resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3, extname as extname5 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 var linterInputSchema = z7.object({
   paths: z7.array(z7.string()).optional().describe("File or directory paths to check for lint errors. If not provided, returns diagnostics for all recently touched files."),
@@ -3186,7 +3327,7 @@ Working directory: ${options.workingDirectory}`,
         const filesToCheck = [];
         for (const path of paths) {
           const absolutePath = isAbsolute3(path) ? path : resolve7(options.workingDirectory, path);
-          if (!existsSync10(absolutePath)) {
+          if (!existsSync11(absolutePath)) {
             continue;
           }
           const stats = await stat2(absolutePath);
@@ -3679,17 +3820,17 @@ import { tool as tool9 } from "ai";
 import { z as z10 } from "zod";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { readFile as readFile8, stat as stat3, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile9, stat as stat3, readdir as readdir4 } from "fs/promises";
 import { resolve as resolve9, relative as relative8, isAbsolute as isAbsolute5 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 init_semantic();
 
 // src/tools/code-graph.ts
 import { tool as tool7 } from "ai";
 import { z as z8 } from "zod";
 import { resolve as resolve8, relative as relative7, isAbsolute as isAbsolute4, basename as basename3 } from "path";
-import { readFile as readFile7, readdir as readdir3 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile8, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execFileSync } from "child_process";
 var codeGraphInputSchema = z8.object({
@@ -3826,7 +3967,7 @@ async function grepForSymbol(symbol, workingDirectory) {
           const ext = entry.name.substring(entry.name.lastIndexOf("."));
           if (!SUPPORTED_EXTS.has(ext)) continue;
           remaining--;
-          const content = await readFile7(fullPath, "utf-8");
+          const content = await readFile8(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             if (defPattern.test(lines[i])) {
@@ -3875,7 +4016,7 @@ Working directory: ${options.workingDirectory}`,
         let defSymbol = null;
         if (filePath) {
           const absPath = isAbsolute4(filePath) ? filePath : resolve8(options.workingDirectory, filePath);
-          if (!existsSync11(absPath)) {
+          if (!existsSync12(absPath)) {
             return { success: false, error: `File not found: ${filePath}` };
           }
           if (!isSupported(absPath)) {
@@ -3889,7 +4030,7 @@ Working directory: ${options.workingDirectory}`,
             defLine = defSymbol.selectionRange.start.line;
             defChar = defSymbol.selectionRange.start.character;
           } else {
-            const content = await readFile7(absPath, "utf-8");
+            const content = await readFile8(absPath, "utf-8");
             const lines2 = content.split("\n");
             const defPattern = new RegExp(
               `(export|function|const|let|var|class|interface|type|enum)\\s+.*\\b${symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`
@@ -4302,7 +4443,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
         execute: async ({ path, startLine, endLine }) => {
           try {
             const absolutePath = isAbsolute5(path) ? path : resolve9(workingDirectory, path);
-            if (!existsSync13(absolutePath)) {
+            if (!existsSync14(absolutePath)) {
               return {
                 success: false,
                 error: `File not found: ${path}`
@@ -4315,7 +4456,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
                 error: `File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Use startLine/endLine to read portions.`
               };
             }
-            let content = await readFile8(absolutePath, "utf-8");
+            let content = await readFile9(absolutePath, "utf-8");
             if (startLine !== void 0 || endLine !== void 0) {
               const lines = content.split("\n");
               const start = (startLine ?? 1) - 1;
@@ -4346,7 +4487,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
         execute: async ({ path, recursive, maxDepth }) => {
           try {
             const absolutePath = isAbsolute5(path) ? path : resolve9(workingDirectory, path);
-            if (!existsSync13(absolutePath)) {
+            if (!existsSync14(absolutePath)) {
               return {
                 success: false,
                 error: `Directory not found: ${path}`
@@ -4713,8 +4854,8 @@ function createTaskFailedTool(options) {
 // src/tools/upload-file.ts
 import { tool as tool12 } from "ai";
 import { z as z13 } from "zod";
-import { readFile as readFile9, stat as stat4 } from "fs/promises";
-import { join as join6, basename as basename4, extname as extname7 } from "path";
+import { readFile as readFile10, stat as stat4 } from "fs/promises";
+import { join as join7, basename as basename4, extname as extname7 } from "path";
 var MIME_TYPES = {
   ".txt": "text/plain",
   ".md": "text/markdown",
@@ -4756,7 +4897,7 @@ function createUploadFileTool(options) {
             error: "File upload is not available \u2014 remote server with GCS is not configured."
           };
         }
-        const fullPath = input.path.startsWith("/") ? input.path : join6(options.workingDirectory, input.path);
+        const fullPath = input.path.startsWith("/") ? input.path : join7(options.workingDirectory, input.path);
         try {
           await stat4(fullPath);
         } catch {
@@ -4774,7 +4915,7 @@ function createUploadFileTool(options) {
           contentType,
           "general"
         );
-        const fileData = await readFile9(fullPath);
+        const fileData = await readFile10(fullPath);
         const putRes = await fetch(uploadInfo.uploadUrl, {
           method: "PUT",
           headers: { "Content-Type": contentType },
@@ -4829,7 +4970,8 @@ async function createTools(options) {
       onProgress: options.onWriteFileProgress
     }),
     todo: createTodoTool({
-      sessionId: options.sessionId
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory
     }),
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,