@saga-ai/cli 0.7.1 → 0.8.0

package/README.md

@@ -85,15 +85,12 @@ saga implement my-story
 saga implement my-story --max-cycles 5
 saga implement my-story --max-time 30
 saga implement my-story --model sonnet
-saga implement my-story --attached --stream
 ```
 
 Options:
 - `--max-cycles <n>` - Maximum number of worker cycles (default: 10)
 - `--max-time <n>` - Maximum time in minutes (default: 60)
 - `--model <name>` - Model to use (default: opus)
-- `--attached` - Run in attached mode (synchronous). Default is detached (runs in tmux session)
-- `--stream` - Stream worker output to stdout (only works with `--attached`)
 
 By default, `implement` runs in **detached mode** using a tmux session. This allows the worker to continue running even if your terminal disconnects. Use `saga sessions` to monitor detached sessions.
 

package/dist/cli.cjs

@@ -630,6 +630,9 @@ async function createSession(epicSlug, storySlug, command) {
 # Auto-generated wrapper script for SAGA session
 set -e
 
+# Mark this as an internal SAGA session (used by CLI to detect it's running inside tmux)
+export SAGA_INTERNAL_SESSION=1
+
 COMMAND_FILE="${commandFilePath}"
 OUTPUT_FILE="${outputFile}"
 SCRIPT_FILE="${wrapperScriptPath}"
@@ -958,64 +961,6 @@ function buildScopeSettings() {
     }
   };
 }
-function parseWorkerOutput(output) {
-  if (!output || !output.trim()) {
-    throw new Error("Worker output is empty");
-  }
-  let cliResponse;
-  try {
-    cliResponse = JSON.parse(output.trim());
-  } catch (e) {
-    throw new Error(`Invalid JSON in worker output: ${e}`);
-  }
-  if (!("structured_output" in cliResponse)) {
-    if (cliResponse.is_error) {
-      const errorMsg = cliResponse.result || "Unknown error";
-      throw new Error(`Worker failed: ${errorMsg}`);
-    }
-    throw new Error(`Worker output missing structured_output field. Got keys: ${Object.keys(cliResponse).join(", ")}`);
-  }
-  const parsed = cliResponse.structured_output;
-  if (!("status" in parsed)) {
-    throw new Error("Worker output missing required field: status");
-  }
-  if (!("summary" in parsed)) {
-    throw new Error("Worker output missing required field: summary");
-  }
-  if (!VALID_STATUSES.has(parsed.status)) {
-    throw new Error(`Invalid status value: ${parsed.status}. Must be one of: ${[...VALID_STATUSES].join(", ")}`);
-  }
-  return {
-    status: parsed.status,
-    summary: parsed.summary,
-    blocker: parsed.blocker ?? null
-  };
-}
-function spawnWorker(prompt, model, settings, workingDir) {
-  const args = [
-    "-p",
-    prompt,
-    "--model",
-    model,
-    "--output-format",
-    "json",
-    "--json-schema",
-    JSON.stringify(WORKER_OUTPUT_SCHEMA),
-    "--settings",
-    JSON.stringify(settings),
-    "--dangerously-skip-permissions"
-  ];
-  const result = (0, import_node_child_process2.spawnSync)("claude", args, {
-    cwd: workingDir,
-    encoding: "utf-8",
-    maxBuffer: 50 * 1024 * 1024
-    // 50MB buffer for large outputs
-  });
-  if (result.error) {
-    throw new Error(`Failed to spawn worker: ${result.error.message}`);
-  }
-  return result.stdout || "";
-}
 function formatStreamLine(line) {
   try {
     const data = JSON.parse(line);
@@ -1142,7 +1087,7 @@ function spawnWorkerAsync(prompt, model, settings, workingDir) {
     });
   });
 }
-async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot, stream = false) {
+async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot) {
   const worktree = (0, import_node_path5.join)(projectDir, ".saga", "worktrees", epicSlug, storySlug);
   const validation = validateStoryFiles(worktree, epicSlug, storySlug);
   if (!validation.valid) {
@@ -1185,55 +1130,25 @@ async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDi
     }
     cycles += 1;
     let parsed;
-    if (stream) {
-      console.log(`
+    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(`
+    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") {
       finalStatus = "FINISH";
@@ -1260,7 +1175,7 @@ async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDi
   };
 }
 function buildDetachedCommand(storySlug, projectPath, options) {
-  const parts = ["saga", "implement", storySlug, "--attached"];
+  const parts = ["saga", "implement", storySlug];
   parts.push("--path", projectPath);
   if (options.maxCycles !== void 0) {
     parts.push("--max-cycles", String(options.maxCycles));
@@ -1271,9 +1186,6 @@ function buildDetachedCommand(storySlug, projectPath, options) {
   if (options.model !== void 0) {
     parts.push("--model", options.model);
   }
-  if (options.stream) {
-    parts.push("--stream");
-  }
   return shellEscapeArgs(parts);
 }
 async function implementCommand(storySlug, options) {
@@ -1316,18 +1228,12 @@ Searched in: ${(0, import_node_path5.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;
-  const attached = options.attached ?? false;
-  if (!attached) {
-    if (stream) {
-      console.error("Warning: --stream is ignored in detached mode. Use --attached --stream for streaming output.");
-    }
+  const isInternalSession = process.env.SAGA_INTERNAL_SESSION === "1";
+  if (!isInternalSession) {
     const detachedCommand = buildDetachedCommand(storySlug, projectPath, {
       maxCycles: options.maxCycles,
       maxTime: options.maxTime,
-      model: options.model,
-      stream: true
-      // Always use streaming in detached mode so output is captured
+      model: options.model
     });
     try {
       const sessionResult = await createSession(
@@ -1353,7 +1259,6 @@ Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`)
   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 = await runLoop(
     storyInfo.epicSlug,
@@ -1362,8 +1267,7 @@ Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`)
     maxTime,
     model,
     projectPath,
-    pluginRoot,
-    stream
+    pluginRoot
   );
   console.log(JSON.stringify(result, null, 2));
   if (result.status === "ERROR") {
@@ -1374,6 +1278,7 @@ Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`)
 // src/server/index.ts
 var import_express2 = __toESM(require("express"), 1);
 var import_http = require("http");
+var import_path6 = require("path");
 
 // src/server/routes.ts
 var import_express = require("express");
@@ -1430,7 +1335,7 @@ function validateTaskStatus(status) {
   return "pending";
 }
 async function parseStory(storyPath, epicSlug) {
-  const { join: join12 } = await import("path");
+  const { join: join13 } = await import("path");
   const { stat: stat2 } = await import("fs/promises");
   let content;
   try {
@@ -1450,7 +1355,7 @@ async function parseStory(storyPath, epicSlug) {
   const title = frontmatter.title || dirName;
   const status = validateStatus(frontmatter.status);
   const tasks = parseTasks(frontmatter.tasks);
-  const journalPath = join12(storyDir, "journal.md");
+  const journalPath = join13(storyDir, "journal.md");
   let hasJournal = false;
   try {
     await stat2(journalPath);
@@ -1976,6 +1881,11 @@ function createApp(sagaRoot) {
     res.json({ status: "ok" });
   });
   app.use("/api", createApiRouter(sagaRoot));
+  const clientDistPath = (0, import_path6.join)(__dirname, "client");
+  app.use(import_express2.default.static(clientDistPath));
+  app.get("/{*splat}", (_req, res) => {
+    res.sendFile((0, import_path6.join)(clientDistPath, "index.html"));
+  });
   return app;
 }
 async function startServer(config) {
@@ -2307,16 +2217,14 @@ program.command("init").description("Initialize .saga/ directory structure").opt
   const globalOpts = program.opts();
   await initCommand({ path: globalOpts.path, dryRun: options.dryRun });
 });
-program.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").option("--attached", "Run in attached mode (synchronous, tied to terminal)").action(async (storySlug, options) => {
+program.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) => {
   const globalOpts = program.opts();
   await implementCommand(storySlug, {
     path: globalOpts.path,
     maxCycles: options.maxCycles,
     maxTime: options.maxTime,
     model: options.model,
-    dryRun: options.dryRun,
-    stream: options.stream,
-    attached: options.attached
+    dryRun: options.dryRun
   });
 });
 program.command("find <query>").description("Find an epic or story by slug/title").option("--type <type>", "Type to search for: epic or story (default: story)").option("--status <status>", "Filter stories by status (e.g., ready, in-progress, completed)").action(async (query, options) => {