npm - @splinterzzz/ouro - Versions diffs - 0.1.3 → 0.1.5 - Mend

@splinterzzz/ouro 0.1.3 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dashboard-dist/assets/index-D-niaPon.js +64 -0
package/dashboard-dist/index.html +1 -1
package/package.json +1 -1
package/src/lib/claudeCodeExec.js +4 -1
package/src/lib/codexExec.js +3 -1
package/src/lib/config.js +9 -0
package/src/lib/daemon.js +16 -1
package/src/server/index.js +136 -76
package/dashboard-dist/assets/index-DERJjla9.js +0 -64

package/dashboard-dist/index.html CHANGED Viewed

@@ -9,7 +9,7 @@
          flash white around a near-black app on load. -->
     <meta name="theme-color" content="#0b0a12" />
     <title>ouro</title>
-    <script type="module" crossorigin src="/assets/index-DERJjla9.js"></script>
+    <script type="module" crossorigin src="/assets/index-D-niaPon.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C21ZXjPS.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@splinterzzz/ouro",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Loop engineering CLI: repo-rooted kanban + agent loop, powered by Claude Code / Codex headless mode (no API key required).",
   "type": "module",
   "keywords": [

package/src/lib/claudeCodeExec.js CHANGED Viewed

@@ -55,7 +55,10 @@ function runClaude(args, { cwd, onEvent, signal } = {}) {
   return new Promise((resolve, reject) => {
     // `signal` wires cancellation straight to the child: aborting SIGTERMs the
     // CLI rather than leaving it running detached. See lib/runs.js.
-    const proc = spawn(CLAUDE_BIN, args, { cwd, env: process.env, signal });
+    // windowsHide: the dashboard daemon spawns this per run — without it, each
+    // run flashes an empty `claude` console window on Windows. Output is piped
+    // and parsed here, so the child never needs a visible console of its own.
+    const proc = spawn(CLAUDE_BIN, args, { cwd, env: process.env, signal, windowsHide: true });
     const rl = readline.createInterface({ input: proc.stdout });
     let sessionId = null;

package/src/lib/codexExec.js CHANGED Viewed

@@ -63,7 +63,9 @@ function agentFlags(agent) {
 function runCodexExec(args, { cwd, onEvent, signal } = {}) {
   return new Promise((resolve, reject) => {
     // `signal` makes cancellation kill the child process. See lib/runs.js.
-    const proc = spawn(CODEX_BIN, args, { cwd, env: process.env, signal });
+    // windowsHide: keep the per-run child from flashing an empty console window
+    // on Windows — output is piped and parsed here, not shown in a console.
+    const proc = spawn(CODEX_BIN, args, { cwd, env: process.env, signal, windowsHide: true });
     const rl = readline.createInterface({ input: proc.stdout });
     let sessionId = null;

package/src/lib/config.js CHANGED Viewed

@@ -16,6 +16,10 @@ const DEFAULTS = {
   // explicit "Create PR" button instead — pushing is outward-facing, so this
   // is deliberately a knob and not a hardcode.
   autoShip: true,
+  // Ceiling on agent-loop QA loop-back re-runs (enterStaging) before the ticket
+  // escalates to a human — a safety valve against a runaway loop that keeps
+  // failing QA and re-running the (expensive) engineer forever.
+  maxQaAttempts: 3,
   telegram: {
     botTokenEnvVar: "OURO_TELEGRAM_BOT_TOKEN",
     chatIdEnvVar: "OURO_TELEGRAM_CHAT_ID",
@@ -94,6 +98,11 @@ export function getAutoShip() {
   return readConfig().autoShip !== false;
 }
+export function getMaxQaAttempts() {
+  const n = readConfig().maxQaAttempts;
+  return Number.isInteger(n) && n >= 1 ? n : 3;
+}
 /** Staging config, each field null when unset (ouro then resolves it per-repo). */
 export function getStaging() {
   const s = readConfig().staging ?? {};

package/src/lib/daemon.js CHANGED Viewed

@@ -60,9 +60,24 @@ export function updateRecord(name, patch) {
   return next;
 }
-/** Signal 0 probes for existence without delivering anything. */
+/**
+ * Signal 0 probes for existence without delivering anything. On win32 this is
+ * unreliable on its own: PIDs recycle fast, and once our dead pid is reused by
+ * an unrelated process owned by another user/session, `process.kill(pid, 0)`
+ * throws EPERM (exists, just not ours) — indistinguishable from our own
+ * still-alive service. That false positive pins a stale pid file forever
+ * (`stop` reports "refused to die" against a ghost). Cross-check with
+ * `tasklist` so a recycled pid isn't mistaken for our service.
+ */
 export function isAlive(pid) {
   if (!pid) return false;
+  if (process.platform === "win32") {
+    const result = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf-8",
+    });
+    const out = result.stdout || "";
+    return out.includes(`"${pid}"`);
+  }
   try {
     process.kill(pid, 0);
     return true;

package/src/server/index.js CHANGED Viewed

@@ -10,7 +10,7 @@ import { contextManifest, listContextFiles, listReferencedFiles } from "../lib/a
 import { appendRunLog, readRunLog } from "../lib/ouroLog.js";
 import { runTests } from "../lib/staging.js";
 import { startPreview, stopPreview, previewInfo } from "../lib/preview.js";
-import { readConfig, writeConfig, getDefaultMode, setDefaultMode, getAutoShip, telegramTokenVar } from "../lib/config.js";
+import { readConfig, writeConfig, getDefaultMode, setDefaultMode, getAutoShip, getMaxQaAttempts, telegramTokenVar } from "../lib/config.js";
 import { readEnvVars, writeEnvVars } from "../lib/env.js";
 import { looksLikeToken, maskToken, verifyBotToken } from "../lib/telegram.js";
 import { startService, stopService, serviceStatus, isAlive, tailLog, uptime } from "../lib/daemon.js";
@@ -103,7 +103,7 @@ export function qaPrompt(ticket, testResult, preview) {
     "3. If it is not a UI change, tests-only is fine.",
     "",
     "Judge the running result against the acceptance criteria and the test results. Never call something ready just because it was asked for.",
-    'Respond with ONLY a JSON object, no prose and no fences: {"ready": boolean, "summary": string, "reasons": string[], "ui_change": boolean, "visual_method": "screenshot"|"html"|"none", "questions": string[]}. When not ready, `reasons` must be concrete and actionable. `questions` are for the human in human-in-loop mode.'
+    'Respond with ONLY a JSON object, no prose and no fences: {"ready": boolean, "summary": string, "reasons": string[], "ui_change": boolean, "visual_method": "screenshot"|"html"|"none", "questions": string[]}. When not ready, `reasons` must be concrete and actionable. `questions` are open items to resolve before shipping — in an agent loop the engineer answers them itself, in human-in-loop the person does.'
   );
   return parts.join("\n");
 }
@@ -139,10 +139,25 @@ export function qaSummaryLine(v) {
 }
 export function qaFeedbackBlock(v) {
-  if (!v?.reasons?.length) return "";
-  return `\n\nThe QA gate sent this back. Address every point before it can ship:\n${v.reasons
-    .map((r, i) => `${i + 1}. ${r}`)
-    .join("\n")}`;
+  const blocks = [];
+  if (v?.reasons?.length) {
+    blocks.push(
+      `The QA gate sent this back. Address every point before it can ship:\n${v.reasons
+        .map((r, i) => `${i + 1}. ${r}`)
+        .join("\n")}`
+    );
+  }
+  // Agent loop: no human will answer QA's questions, so the engineer resolves
+  // them itself. Only reached on the agent-loop loop-back path (enterStaging),
+  // so framing them as "yours to answer" is always accurate here.
+  if (v?.questions?.length) {
+    blocks.push(
+      `QA raised these open questions. This is an agent loop — no human will answer them, so resolve each one yourself: investigate the code, decide, act on it, and state the answer in your final message:\n${v.questions
+        .map((q, i) => `${i + 1}. ${q}`)
+        .join("\n")}`
+    );
+  }
+  return blocks.length ? `\n\n${blocks.join("\n\n")}` : "";
 }
 /**
@@ -339,9 +354,10 @@ export function createServer() {
         appendRunLog(store.get(ticketId), shipOutcome(shipResult));
         return;
       }
-      // Not ready. Loop-stop guard: a 2nd failure escalates to a human,
-      // regardless of mode — don't loop forever.
-      if (attempt >= 2) {
+      // Not ready. Loop-stop guard: once we hit the configurable ceiling
+      // (maxQaAttempts) the ticket escalates to a human, regardless of mode —
+      // don't loop forever re-running the expensive engineer.
+      if (attempt >= getMaxQaAttempts()) {
         store.update(ticketId, { awaitingQa: true, escalated: true });
         appendRunLog(store.get(ticketId), `QA failed ${attempt}× — escalated to human`);
         return;
@@ -361,36 +377,29 @@ export function createServer() {
     }
   }
-  // --- tickets ---
-  app.get("/api/tickets", (_req, res) => {
-    res.json(store.list());
-  });
-  app.post("/api/tickets", (req, res) => {
-    const { title, body, source, agentId, mode, priority, summary } = req.body;
-    if (!title?.trim()) return res.status(400).json({ error: "title is required" });
-    res.json(store.create({ title: title.trim(), body: body ?? "", source, agentId, mode, priority, summary }));
-  });
-  app.post("/api/tickets/:id/analyze", async (req, res) => {
-    const ticket = store.get(req.params.id);
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+  /**
+   * The read-only Analyst pass, factored out of its route so the auto-pipeline
+   * can chain it into a run without a second HTTP hop. Owns its own run
+   * registration and the transient `analyzing` flag, and returns `{ ok }` so a
+   * caller can decide whether to proceed — abort or a caught error is `ok:false`
+   * (the error is still logged to the ticket, as when a human clicked Analyze).
+   */
+  async function runAnalyze(ticketId) {
+    const ticket = store.get(ticketId);
+    if (!ticket || runs.isRunning(ticketId)) return { ok: false };
     let signal;
     try {
-      signal = runs.begin(ticket.id, "analyze");
-    } catch (err) {
-      return res.status(409).json({ error: String(err.message || err) });
+      signal = runs.begin(ticketId, "analyze");
+    } catch {
+      return { ok: false };
     }
-    res.json({ started: true });
     // Analyze is read-only and leaves the ticket where it is; a transient flag
     // drives the card's "Analyzing…" state without faking a worktree run.
-    store.update(ticket.id, { analyzing: true });
+    store.update(ticketId, { analyzing: true });
-    const onEvent = (event) => store.appendLog(ticket.id, { type: "agent_event", event });
+    const onEvent = (event) => store.appendLog(ticketId, { type: "agent_event", event });
     try {
       // Always the Analyst agent for this step, regardless of the ticket's
@@ -406,8 +415,8 @@ export function createServer() {
         onEvent,
         agent: analyst,
       });
-      if (signal.aborted) return; // cancelled mid-analysis — /cancel already reconciled it
-      store.update(ticket.id, {
+      if (signal.aborted) return { ok: false }; // cancelled mid-analysis — /cancel already reconciled it
+      store.update(ticketId, {
         status: "analyzed",
         analyzing: false,
         summary: result.summary,
@@ -415,51 +424,39 @@ export function createServer() {
         filesLikelyAffected: Array.isArray(result.files_likely_affected) ? result.files_likely_affected : [],
         acceptanceCriteria: Array.isArray(result.acceptance_criteria) ? result.acceptance_criteria : [],
       });
+      return { ok: true };
     } catch (err) {
-      store.update(ticket.id, { analyzing: false });
-      store.appendLog(ticket.id, { type: "error", text: String(err.message || err) });
+      store.update(ticketId, { analyzing: false });
+      store.appendLog(ticketId, { type: "error", text: String(err.message || err) });
+      return { ok: false };
     } finally {
-      runs.end(ticket.id);
+      runs.end(ticketId);
     }
-  });
-  app.post("/api/tickets/:id/mode", (req, res) => {
-    const { mode } = req.body; // "agent" | "human" | null (inherit board default)
-    if (mode !== null && mode !== "agent" && mode !== "human") {
-      return res.status(400).json({ error: "mode must be 'agent', 'human', or null" });
-    }
-    const ticket = store.update(req.params.id, { mode });
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    res.json(ticket);
-  });
-  app.post("/api/tickets/:id/agent", (req, res) => {
-    const { agentId } = req.body;
-    if (agentId && !getAgent(agentId)) return res.status(400).json({ error: `no such agent: ${agentId}` });
-    const ticket = store.update(req.params.id, { agentId: agentId ?? null });
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    res.json(ticket);
-  });
+  }
-  app.post("/api/tickets/:id/run", async (req, res) => {
-    const ticket = store.get(req.params.id);
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+  /**
+   * The implementation run, factored out of its route for the same reason. Owns
+   * its own run registration, resolves mode/agent, resets the staging state to a
+   * clean QA budget, cuts the worktree, then either runs the agent straight into
+   * Staging (agent mode) or plans and waits for approval (human mode).
+   */
+  async function runImplementation(ticketId) {
+    const ticket = store.get(ticketId);
+    if (!ticket || runs.isRunning(ticketId)) return;
     const mode = resolveMode(ticket);
     const agent = resolveAgent(ticket);
     let signal;
     try {
-      signal = runs.begin(ticket.id, mode);
-    } catch (err) {
-      return res.status(409).json({ error: String(err.message || err) });
+      signal = runs.begin(ticketId, mode);
+    } catch {
+      return;
     }
-    res.json({ started: true, mode, agentId: agent?.id ?? null });
     // A fresh run resets the staging state so a re-run starts with a clean QA
     // budget (the loop-stop guard counts from here).
-    store.update(ticket.id, {
+    store.update(ticketId, {
       status: "in_progress",
       mode,
       agentId: agent?.id ?? ticket.agentId,
@@ -471,11 +468,11 @@ export function createServer() {
       escalated: false,
     });
-    const onEvent = (event) => store.appendLog(ticket.id, { type: "agent_event", event });
+    const onEvent = (event) => store.appendLog(ticketId, { type: "agent_event", event });
     try {
-      const { dir: worktreeDir, branch, base } = await createTicketWorktree(ticket.id);
-      store.update(ticket.id, { worktree: worktreeDir, branch, baseBranch: base });
+      const { dir: worktreeDir, branch, base } = await createTicketWorktree(ticketId);
+      store.update(ticketId, { worktree: worktreeDir, branch, baseBranch: base });
       const prompt = buildImplementationPrompt(ticket);
@@ -483,17 +480,17 @@ export function createServer() {
         // Full autonomy, single call.
         const result = await runAgent({ prompt, cwd: worktreeDir, onEvent, signal, agent });
         if (result.aborted) return; // cancel route already marked it
-        const diff = await diffWorktree(ticket.id).catch(() => null);
-        store.update(ticket.id, { status: "staging", diff, sessionId: result.sessionId, awaitingApproval: false });
+        const diff = await diffWorktree(ticketId).catch(() => null);
+        store.update(ticketId, { status: "staging", diff, sessionId: result.sessionId, awaitingApproval: false });
         // Validate in Staging before anything ships — the QA gate stands between
         // a finished run and the PR.
-        await enterStaging(ticket.id, { signal, onEvent, mode });
+        await enterStaging(ticketId, { signal, onEvent, mode });
       } else {
         // Human-in-the-loop: plan only, no writes yet. The card shows the
         // plan and waits for an explicit Approve before phase 2 runs.
         const result = await planTicket({ prompt, cwd: worktreeDir, onEvent, signal, agent });
         if (result.aborted) return;
-        store.update(ticket.id, {
+        store.update(ticketId, {
           status: "staging",
           sessionId: result.sessionId,
           plan: result.lastMessage,
@@ -501,12 +498,75 @@ export function createServer() {
         });
       }
     } catch (err) {
-      store.appendLog(ticket.id, { type: "error", text: String(err.message || err) });
-      store.cancel(ticket.id, `Run failed: ${err.message || err}`);
-      appendRunLog(store.get(ticket.id), `failed: ${String(err.message || err).split("\n")[0].slice(0, 60)}`);
+      store.appendLog(ticketId, { type: "error", text: String(err.message || err) });
+      store.cancel(ticketId, `Run failed: ${err.message || err}`);
+      appendRunLog(store.get(ticketId), `failed: ${String(err.message || err).split("\n")[0].slice(0, 60)}`);
     } finally {
-      runs.end(ticket.id);
+      runs.end(ticketId);
     }
+  }
+  // Agent loop is hands-off from intake onward: a freshly created agent-mode
+  // ticket analyzes then runs on its own — the Telegram interview is the only
+  // human touch until the PR. A failed/cancelled analyze leaves it in Inbox
+  // rather than running blind. Human mode leaves it in Inbox for the buttons.
+  async function autoPipeline(ticketId) {
+    const analysis = await runAnalyze(ticketId);
+    if (!analysis?.ok) return;
+    if (store.get(ticketId)?.status !== "analyzed") return;
+    await runImplementation(ticketId);
+  }
+  // --- tickets ---
+  app.get("/api/tickets", (_req, res) => {
+    res.json(store.list());
+  });
+  app.post("/api/tickets", (req, res) => {
+    const { title, body, source, agentId, mode, priority, summary } = req.body;
+    if (!title?.trim()) return res.status(400).json({ error: "title is required" });
+    const ticket = store.create({ title: title.trim(), body: body ?? "", source, agentId, mode, priority, summary });
+    res.json(ticket);
+    if (resolveMode(ticket) === "agent") {
+      autoPipeline(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: `auto-pipeline: ${String(err.message || err)}` }));
+    }
+  });
+  app.post("/api/tickets/:id/analyze", (req, res) => {
+    const ticket = store.get(req.params.id);
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+    res.json({ started: true });
+    runAnalyze(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: String(err.message || err) }));
+  });
+  app.post("/api/tickets/:id/mode", (req, res) => {
+    const { mode } = req.body; // "agent" | "human" | null (inherit board default)
+    if (mode !== null && mode !== "agent" && mode !== "human") {
+      return res.status(400).json({ error: "mode must be 'agent', 'human', or null" });
+    }
+    const ticket = store.update(req.params.id, { mode });
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    res.json(ticket);
+  });
+  app.post("/api/tickets/:id/agent", (req, res) => {
+    const { agentId } = req.body;
+    if (agentId && !getAgent(agentId)) return res.status(400).json({ error: `no such agent: ${agentId}` });
+    const ticket = store.update(req.params.id, { agentId: agentId ?? null });
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    res.json(ticket);
+  });
+  app.post("/api/tickets/:id/run", (req, res) => {
+    const ticket = store.get(req.params.id);
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+    const mode = resolveMode(ticket);
+    const agent = resolveAgent(ticket);
+    res.json({ started: true, mode, agentId: agent?.id ?? null });
+    runImplementation(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: String(err.message || err) }));
   });
   app.post("/api/tickets/:id/approve", async (req, res) => {
@@ -693,7 +753,7 @@ export function createServer() {
     // ouro already holding the port. Without it, a probe that gets a 200 only
     // proves someone is listening — not that the process we just spawned is
     // the one answering.
-    res.json({ backend: getBackendName(), defaultMode: getDefaultMode(), autoShip: getAutoShip(), pid: process.pid, config });
+    res.json({ backend: getBackendName(), defaultMode: getDefaultMode(), autoShip: getAutoShip(), maxQaAttempts: getMaxQaAttempts(), pid: process.pid, config });
   });
   app.post("/api/config/backend", (req, res) => {