@saga-ai/cli 0.3.0 → 0.5.0

package/dist/cli.cjs

@@ -3037,7 +3037,7 @@ var {
 } = import_index.default;
 
 // src/cli.ts
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var import_node_fs6 = require("node:fs");
 
 // src/commands/init.ts
@@ -4957,7 +4957,7 @@ function buildScopeSettings() {
     hooks: {
       PreToolUse: [
         {
-          matcher: "Read|Write|Edit",
+          matcher: "Read|Write|Edit|Glob|Grep",
           hooks: [hookCommand]
         }
       ]
@@ -5022,7 +5022,114 @@ function spawnWorker(prompt, model, settings, workingDir) {
   }
   return result.stdout || "";
 }
-function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot) {
+function formatStreamLine(line) {
+  try {
+    const data = JSON.parse(line);
+    if (data.type === "assistant" && data.message?.content) {
+      for (const block of data.message.content) {
+        if (block.type === "text" && block.text) {
+          return block.text;
+        }
+        if (block.type === "tool_use") {
+          return `[Tool: ${block.name}]`;
+        }
+      }
+    }
+    if (data.type === "system" && data.subtype === "init") {
+      return `[Session started: ${data.session_id}]`;
+    }
+    if (data.type === "result") {
+      const status = data.subtype === "success" ? "completed" : "failed";
+      return `
+[Worker ${status} in ${Math.round(data.duration_ms / 1e3)}s]`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseStreamingResult(buffer) {
+  const lines = buffer.split("\n").filter((line) => line.trim());
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const data = JSON.parse(lines[i]);
+      if (data.type === "result") {
+        if (data.is_error) {
+          throw new Error(`Worker failed: ${data.result || "Unknown error"}`);
+        }
+        if (!data.structured_output) {
+          throw new Error("Worker result missing structured_output");
+        }
+        const output = data.structured_output;
+        if (!VALID_STATUSES.has(output.status)) {
+          throw new Error(`Invalid status: ${output.status}`);
+        }
+        return {
+          status: output.status,
+          summary: output.summary || "",
+          blocker: output.blocker ?? null
+        };
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Worker")) {
+        throw e;
+      }
+    }
+  }
+  throw new Error("No result found in worker output");
+}
+function spawnWorkerAsync(prompt, model, settings, workingDir) {
+  return new Promise((resolve2, reject) => {
+    let buffer = "";
+    const args = [
+      "-p",
+      prompt,
+      "--model",
+      model,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--json-schema",
+      JSON.stringify(WORKER_OUTPUT_SCHEMA),
+      "--settings",
+      JSON.stringify(settings),
+      "--dangerously-skip-permissions"
+    ];
+    const child = (0, import_node_child_process.spawn)("claude", args, {
+      cwd: workingDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      buffer += text;
+      const lines = text.split("\n");
+      for (const line of lines) {
+        if (line.trim()) {
+          const formatted = formatStreamLine(line);
+          if (formatted) {
+            process.stdout.write(formatted);
+          }
+        }
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      process.stderr.write(chunk);
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn worker: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      process.stdout.write("\n");
+      try {
+        const result = parseStreamingResult(buffer);
+        resolve2(result);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot, stream = false) {
   const worktree = (0, import_node_path4.join)(projectDir, ".saga", "worktrees", epicSlug, storySlug);
   const validation = validateStoryFiles(worktree, epicSlug, storySlug);
   if (!validation.valid) {
@@ -5064,33 +5171,55 @@ function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, plu
       break;
     }
     cycles += 1;
-    let output;
-    try {
-      output = spawnWorker(workerPrompt, model, settings, worktree);
-    } catch (e) {
-      return {
-        status: "ERROR",
-        summary: e.message,
-        cycles,
-        elapsedMinutes: (Date.now() - startTime) / 6e4,
-        blocker: null,
-        epicSlug,
-        storySlug
-      };
-    }
     let parsed;
-    try {
-      parsed = parseWorkerOutput(output);
-    } catch (e) {
-      return {
-        status: "ERROR",
-        summary: e.message,
-        cycles,
-        elapsedMinutes: (Date.now() - startTime) / 6e4,
-        blocker: null,
-        epicSlug,
-        storySlug
-      };
+    if (stream) {
+      console.log(`
+--- Worker ${cycles} started ---
+`);
+      try {
+        parsed = await spawnWorkerAsync(workerPrompt, model, settings, worktree);
+      } catch (e) {
+        return {
+          status: "ERROR",
+          summary: e.message,
+          cycles,
+          elapsedMinutes: (Date.now() - startTime) / 6e4,
+          blocker: null,
+          epicSlug,
+          storySlug
+        };
+      }
+      console.log(`
+--- Worker ${cycles} result: ${parsed.status} ---
+`);
+    } else {
+      let output;
+      try {
+        output = spawnWorker(workerPrompt, model, settings, worktree);
+      } catch (e) {
+        return {
+          status: "ERROR",
+          summary: e.message,
+          cycles,
+          elapsedMinutes: (Date.now() - startTime) / 6e4,
+          blocker: null,
+          epicSlug,
+          storySlug
+        };
+      }
+      try {
+        parsed = parseWorkerOutput(output);
+      } catch (e) {
+        return {
+          status: "ERROR",
+          summary: e.message,
+          cycles,
+          elapsedMinutes: (Date.now() - startTime) / 6e4,
+          blocker: null,
+          epicSlug,
+          storySlug
+        };
+      }
     }
     summaries.push(parsed.summary);
     if (parsed.status === "FINISH") {
@@ -5157,19 +5286,22 @@ Searched in: ${(0, import_node_path4.join)(projectPath, ".saga", "worktrees")}`)
   const maxCycles = options.maxCycles ?? DEFAULT_MAX_CYCLES;
   const maxTime = options.maxTime ?? DEFAULT_MAX_TIME;
   const model = options.model ?? DEFAULT_MODEL;
+  const stream = options.stream ?? false;
   console.log("Starting story implementation...");
   console.log(`  Epic: ${storyInfo.epicSlug}`);
   console.log(`  Story: ${storyInfo.storySlug}`);
   console.log(`  Worktree: ${storyInfo.worktreePath}`);
+  console.log(`  Streaming: ${stream ? "enabled" : "disabled"}`);
   console.log("");
-  const result = runLoop(
+  const result = await runLoop(
     storyInfo.epicSlug,
     storyInfo.storySlug,
     maxCycles,
     maxTime,
     model,
     projectPath,
-    pluginRoot
+    pluginRoot,
+    stream
   );
   console.log(JSON.stringify(result, null, 2));
   if (result.status === "ERROR") {
@@ -5196,10 +5328,12 @@ async function dashboardCommand(options) {
 }
 
 // src/commands/scope-validator.ts
-function getFilePathFromInput(toolInput) {
+var import_node_path5 = require("node:path");
+function getFilePathFromInput(hookInput) {
   try {
-    const data = JSON.parse(toolInput);
-    return data.file_path || data.path || null;
+    const data = JSON.parse(hookInput);
+    const toolInput = data.tool_input || {};
+    return toolInput.file_path || toolInput.path || null;
   } catch {
     return null;
   }
@@ -5213,6 +5347,15 @@ function normalizePath(path) {
 function isArchiveAccess(path) {
   return path.includes(".saga/archive");
 }
+function isWithinWorktree(filePath, worktreePath) {
+  const absoluteFilePath = (0, import_node_path5.resolve)(filePath);
+  const absoluteWorktree = (0, import_node_path5.resolve)(worktreePath);
+  const relativePath = (0, import_node_path5.relative)(absoluteWorktree, absoluteFilePath);
+  if (relativePath.startsWith("..") || (0, import_node_path5.resolve)(relativePath) === relativePath) {
+    return false;
+  }
+  return true;
+}
 function checkStoryAccess(path, allowedEpic, allowedStory) {
   if (!path.includes(".saga/epics/")) {
     return true;
@@ -5233,24 +5376,27 @@ function checkStoryAccess(path, allowedEpic, allowedStory) {
     return pathEpic === allowedEpic;
   }
 }
-function printScopeViolation(filePath, epicSlug, storySlug, reason) {
+function printScopeViolation(filePath, epicSlug, storySlug, worktreePath, reason) {
   console.error(`SCOPE VIOLATION: ${reason}
 
 Attempted path: ${filePath}
 
 Your scope is limited to:
+  Worktree: ${worktreePath}
   Epic: ${epicSlug}
   Story: ${storySlug}
-  Allowed: .saga/epics/${epicSlug}/stories/${storySlug}/
+  Allowed story files: .saga/epics/${epicSlug}/stories/${storySlug}/
 
+Workers cannot access files outside the worktree directory.
 To access other stories, start a new /implement session for that story.`);
 }
 async function scopeValidatorCommand() {
+  const worktreePath = process.env.SAGA_PROJECT_DIR || "";
   const epicSlug = process.env.SAGA_EPIC_SLUG || "";
   const storySlug = process.env.SAGA_STORY_SLUG || "";
-  if (!epicSlug || !storySlug) {
+  if (!worktreePath || !epicSlug || !storySlug) {
     console.error(
-      "ERROR: scope-validator requires SAGA_EPIC_SLUG and SAGA_STORY_SLUG environment variables"
+      "ERROR: scope-validator requires SAGA_PROJECT_DIR, SAGA_EPIC_SLUG, and SAGA_STORY_SLUG environment variables"
     );
     process.exit(2);
   }
@@ -5264,11 +5410,22 @@ async function scopeValidatorCommand() {
     process.exit(0);
   }
   const normPath = normalizePath(filePath);
+  if (!isWithinWorktree(normPath, worktreePath)) {
+    printScopeViolation(
+      filePath,
+      epicSlug,
+      storySlug,
+      worktreePath,
+      "Access outside worktree blocked\nReason: Workers can only access files within their assigned worktree directory."
+    );
+    process.exit(2);
+  }
   if (isArchiveAccess(normPath)) {
     printScopeViolation(
       filePath,
       epicSlug,
       storySlug,
+      worktreePath,
       "Access to archive folder blocked\nReason: The archive folder contains completed stories and is read-only during execution."
     );
     process.exit(2);
@@ -5278,6 +5435,7 @@ async function scopeValidatorCommand() {
       filePath,
       epicSlug,
       storySlug,
+      worktreePath,
       "Access to other story blocked\nReason: Workers can only access their assigned story's files."
     );
     process.exit(2);
@@ -5308,7 +5466,7 @@ async function findCommand(query, options) {
 }
 
 // src/commands/worktree.ts
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 var import_node_fs5 = require("node:fs");
 var import_node_child_process2 = require("node:child_process");
 function runGitCommand(args, cwd) {
@@ -5340,7 +5498,7 @@ function getMainBranch(cwd) {
 }
 function createWorktree(projectPath, epicSlug, storySlug) {
   const branchName = `story-${storySlug}-epic-${epicSlug}`;
-  const worktreePath = (0, import_node_path5.join)(
+  const worktreePath = (0, import_node_path6.join)(
     projectPath,
     ".saga",
     "worktrees",
@@ -5371,7 +5529,7 @@ function createWorktree(projectPath, epicSlug, storySlug) {
       error: `Failed to create branch: ${createBranchResult.output}`
     };
   }
-  const worktreeParent = (0, import_node_path5.join)(projectPath, ".saga", "worktrees", epicSlug);
+  const worktreeParent = (0, import_node_path6.join)(projectPath, ".saga", "worktrees", epicSlug);
   (0, import_node_fs5.mkdirSync)(worktreeParent, { recursive: true });
   const createWorktreeResult = runGitCommand(
     ["worktree", "add", worktreePath, branchName],
@@ -5406,7 +5564,7 @@ async function worktreeCommand(epicSlug, storySlug, options) {
 }
 
 // src/cli.ts
-var packageJsonPath = (0, import_node_path6.join)(__dirname, "..", "package.json");
+var packageJsonPath = (0, import_node_path7.join)(__dirname, "..", "package.json");
 var packageJson = JSON.parse((0, import_node_fs6.readFileSync)(packageJsonPath, "utf-8"));
 var program2 = new Command();
 program2.name("saga").description("CLI for SAGA - Structured Autonomous Goal Achievement").version(packageJson.version).addHelpCommand("help [command]", "Display help for a command");
@@ -5415,14 +5573,15 @@ program2.command("init").description("Initialize .saga/ directory structure").op
   const globalOpts = program2.opts();
   await initCommand({ path: globalOpts.path, dryRun: options.dryRun });
 });
-program2.command("implement <story-slug>").description("Run story implementation").option("--max-cycles <n>", "Maximum number of implementation cycles", parseInt).option("--max-time <n>", "Maximum time in minutes", parseInt).option("--model <name>", "Model to use for implementation").option("--dry-run", "Validate dependencies without running implementation").action(async (storySlug, options) => {
+program2.command("implement <story-slug>").description("Run story implementation").option("--max-cycles <n>", "Maximum number of implementation cycles", parseInt).option("--max-time <n>", "Maximum time in minutes", parseInt).option("--model <name>", "Model to use for implementation").option("--dry-run", "Validate dependencies without running implementation").option("--stream", "Stream worker output in real-time").action(async (storySlug, options) => {
   const globalOpts = program2.opts();
   await implementCommand(storySlug, {
     path: globalOpts.path,
     maxCycles: options.maxCycles,
     maxTime: options.maxTime,
     model: options.model,
-    dryRun: options.dryRun
+    dryRun: options.dryRun,
+    stream: options.stream
   });
 });
 program2.command("find <query>").description("Find an epic or story by slug/title").option("--type <type>", "Type to search for: epic or story (default: story)").action(async (query, options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saga-ai/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "CLI for SAGA - Structured Autonomous Goal Achievement",
   "type": "module",
   "bin": {