aiwcli 0.14.0 → 0.15.1

package/dist/templates/_shared/skills/prompt-codex/scripts/launch-codex.ts

@@ -3,9 +3,9 @@
  * Launch Codex in a tmux pane and inject a prompt into its REPL.
  *
  * Usage:
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] plan
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] --file <path>
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] <inline text...>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] plan
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] --file <path>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] <inline text...>
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -32,6 +32,10 @@ const CODEX_ALIASES: Record<string, string> = {
   gpt: CODEX_MODELS.gpt,
 };
 
+const SESSION_DISCOVERY_TIMEOUT_MS = 12000;
+const SESSION_DISCOVERY_POLL_MS = 250;
+const SESSION_MTIME_WINDOW_MS = 120000;
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -40,6 +44,107 @@ function eprint(...args: unknown[]): void {
   process.stderr.write(args.map(String).join(" ") + "\n");
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function collectSessionJsonlFiles(rootDir: string): string[] {
+  if (!fs.existsSync(rootDir)) return [];
+  const stack: string[] = [rootDir];
+  const files: string[] = [];
+
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir) continue;
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  return files;
+}
+
+function samePath(a: string, b: string): boolean {
+  const left = path.resolve(a);
+  const right = path.resolve(b);
+  if (process.platform === "win32") {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+  return left === right;
+}
+
+function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string } | null {
+  try {
+    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const firstLine = raw.split(/\r?\n/).find((line) => line.trim().length > 0);
+    if (!firstLine) return null;
+    const parsed = JSON.parse(firstLine);
+    if (parsed?.type !== "session_meta") return null;
+    const sessionId = parsed?.payload?.id;
+    const cwd = parsed?.payload?.cwd;
+    if (typeof sessionId !== "string" || typeof cwd !== "string") return null;
+    return { sessionId, cwd };
+  } catch {
+    return null;
+  }
+}
+
+function findLatestSessionCandidate(
+  projectRoot: string,
+  launchStartedAtMs: number,
+): { sessionId: string; sessionFile: string } | null {
+  const sessionsRoot = path.join(os.homedir(), ".codex", "sessions");
+  const files = collectSessionJsonlFiles(sessionsRoot);
+  if (files.length === 0) return null;
+
+  const candidates: Array<{ sessionId: string; sessionFile: string; mtimeMs: number }> = [];
+  for (const sessionFile of files) {
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(sessionFile).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs < launchStartedAtMs - SESSION_MTIME_WINDOW_MS) continue;
+
+    const meta = readSessionMeta(sessionFile);
+    if (!meta) continue;
+    if (!samePath(meta.cwd, projectRoot)) continue;
+
+    candidates.push({ sessionId: meta.sessionId, sessionFile, mtimeMs });
+  }
+
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const best = candidates[0];
+  return best ? { sessionId: best.sessionId, sessionFile: best.sessionFile } : null;
+}
+
+async function waitForCaptureSession(
+  projectRoot: string,
+  launchStartedAtMs: number,
+): Promise<{ sessionId: string; sessionFile: string } | null> {
+  const deadline = Date.now() + SESSION_DISCOVERY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+    if (candidate) return candidate;
+    await sleep(SESSION_DISCOVERY_POLL_MS);
+  }
+  return findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+}
+
 /** Fallback plan discovery: scan all context plan dirs by mtime. */
 function findLatestPlanByMtime(projectRoot: string): string | null {
   const contextsDir = path.join(projectRoot, "_output", "contexts");
@@ -74,7 +179,7 @@ function findLatestPlanByMtime(projectRoot: string): string | null {
 const rawArgs = process.argv.slice(2);
 
 if (rawArgs.length === 0) {
-  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--context <id>] plan | --file <path> | <text...>");
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
   process.exit(1);
 }
 
@@ -82,6 +187,8 @@ if (rawArgs.length === 0) {
 let modelFlag: string | undefined;
 let sandboxFlag: CodexSandbox | undefined;
 let contextFlag: string | undefined;
+let yolo = true;
+let capture = false;
 const args: string[] = [];
 
 for (let i = 0; i < rawArgs.length; i++) {
@@ -96,13 +203,19 @@ for (let i = 0; i < rawArgs.length; i++) {
     sandboxFlag = val;
   } else if (rawArgs[i] === "--context" && i + 1 < rawArgs.length) {
     contextFlag = rawArgs[++i];
+  } else if (rawArgs[i] === "--yolo") {
+    yolo = true;
+  } else if (rawArgs[i] === "--no-yolo") {
+    yolo = false;
+  } else if (rawArgs[i] === "--capture") {
+    capture = true;
   } else {
     args.push(rawArgs[i]);
   }
 }
 
 if (args.length === 0) {
-  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--context <id>] plan | --file <path> | <text...>");
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
   process.exit(1);
 }
 
@@ -206,11 +319,13 @@ if (!tmux.available) {
 // ---------------------------------------------------------------------------
 
 // Build args via centralized CLI builder
-const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag)).args;
+const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag, yolo)).args;
+if (yolo) console.log("Mode: YOLO (bypass approvals and sandbox)");
 if (sandboxFlag) console.log(`Sandbox: ${sandboxFlag}`);
 if (resolvedModel) console.log(`Model: ${resolvedModel}${modelFlag !== resolvedModel ? ` (from "${modelFlag}")` : ""}`);
 
-logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+const launchStartedAtMs = Date.now();
 
 const result = await launchDriverInTmuxOrFallback({
   toolName: "codex",
@@ -248,6 +363,24 @@ if (result.paneId) {
   console.log("Codex launched in tmux pane.");
 }
 
+if (capture && result.paneId) {
+  try {
+    const sessionInfo = await waitForCaptureSession(projectRoot, launchStartedAtMs);
+    if (sessionInfo) {
+      console.log(`CODEX_CAPTURE_PANE=${result.paneId}`);
+      console.log(`CODEX_CAPTURE_SESSION_ID=${sessionInfo.sessionId}`);
+      console.log(`CODEX_CAPTURE_SESSION_FILE=${sessionInfo.sessionFile}`);
+    } else {
+      logWarn(
+        "codex-skill",
+        `Capture session discovery failed for pane ${result.paneId} in ${SESSION_DISCOVERY_TIMEOUT_MS}ms`,
+      );
+    }
+  } catch (error) {
+    logWarn("codex-skill", `Capture session discovery threw for ${result.paneId}: ${String(error)}`);
+  }
+}
+
 if (result.reason) {
   // Partial success (e.g., launched but prompt injection failed)
   eprint(`Warning: ${result.reason}`);

package/dist/templates/_shared/skills/prompt-codex/scripts/watch-codex.ts

@@ -0,0 +1,257 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { inference } from "../../../lib-ts/base/inference.js";
+import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
+import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
+import { execFileAsync } from "../../../lib-ts/base/subprocess-utils.js";
+import { getTmuxAvailability } from "../../../lib-ts/base/tmux-driver.js";
+
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 3000;
+const SUMMARY_TIMEOUT_SEC = 8;
+const RESUME_TIMEOUT_MS = 45000;
+const MAX_TRANSCRIPT_LINES = 220;
+const MAX_LINE_LENGTH = 500;
+const SUMMARY_UNAVAILABLE_MESSAGE = "Codex session completed. Summary unavailable.";
+
+const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Codex session transcript excerpt.
+Return 3-5 concise bullet points.
+Focus on:
+- what was accomplished
+- files changed
+- errors or blockers
+Do not ask follow-up questions.
+Do not request additional input.
+If information is partial, provide best-effort summary from available text.`;
+
+const RESUME_SUMMARY_PROMPT = `Summarize the previous Codex session in 3-5 concise bullet points.
+Focus on:
+- what was accomplished
+- files changed
+- errors or blockers
+Do not ask follow-up questions.
+Do not request additional input.
+If the prior session was brief, still provide a best-effort summary.`;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function safeCleanup(filePath: string): void {
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function readTextIfExists(filePath: string): string {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return "";
+    return fs.readFileSync(filePath, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function normalizeText(text: string): string {
+  return text
+    .replace(/\r/g, "")
+    .replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function getMessageContentText(content: unknown): string {
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((entry: any) => {
+      if (!entry || typeof entry !== "object") return "";
+      if (typeof entry.text !== "string") return "";
+      return entry.text;
+    })
+    .join("\n");
+}
+
+function collectTranscriptLines(sessionFile: string): string[] {
+  if (!sessionFile || !fs.existsSync(sessionFile)) return [];
+
+  const out: string[] = [];
+  const seen = new Set<string>();
+
+  try {
+    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+
+    for (const line of lines) {
+      let parsed: any;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      let role = "";
+      let text = "";
+
+      if (parsed?.type === "response_item" && parsed?.payload?.type === "message") {
+        role = parsed?.payload?.role === "assistant" ? "assistant" : (parsed?.payload?.role === "user" ? "user" : "");
+        text = getMessageContentText(parsed?.payload?.content);
+      } else if (parsed?.type === "item.completed" && parsed?.item?.type === "agent_message" && typeof parsed?.item?.text === "string") {
+        role = "assistant";
+        text = parsed.item.text;
+      } else if (parsed?.type === "event_msg" && parsed?.payload?.type === "agent_message" && typeof parsed?.payload?.message === "string") {
+        role = "assistant";
+        text = parsed.payload.message;
+      }
+
+      const normalized = normalizeText(text);
+      if (!role || !normalized) continue;
+
+      const truncated = normalized.length > MAX_LINE_LENGTH ? `${normalized.slice(0, MAX_LINE_LENGTH)}...` : normalized;
+      const tagged = `${role}: ${truncated}`;
+      if (seen.has(tagged)) continue;
+
+      seen.add(tagged);
+      out.push(tagged);
+    }
+  } catch (error) {
+    logWarn("codex-capture", `Session transcript parse failed: ${String(error)}`);
+  }
+
+  return out.slice(-MAX_TRANSCRIPT_LINES);
+}
+
+function looksLikeBadSummary(output: string): boolean {
+  const normalized = output.toLowerCase();
+  return (
+    normalized.includes("don't see") ||
+    normalized.includes("no output") ||
+    normalized.includes("could you provide") ||
+    normalized.includes("paste")
+  );
+}
+
+async function waitForPaneClose(paneId: string): Promise<void> {
+  const tmux = getTmuxAvailability();
+  if (!tmux.available || !tmux.tmuxPath) {
+    logWarn("codex-capture", `tmux unavailable while watching pane ${paneId}: ${tmux.reason ?? "unknown reason"}`);
+    return;
+  }
+
+  while (true) {
+    const result = await execFileAsync(tmux.tmuxPath, ["list-panes", "-a", "-F", "#{pane_id}"], {
+      timeout: POLL_TIMEOUT_MS,
+    });
+
+    if (result.exitCode !== 0) {
+      logDebug("codex-capture", `list-panes failed; assuming pane closed (${result.stderr.trim() || "no stderr"})`);
+      return;
+    }
+
+    const activePaneIds = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (!activePaneIds.includes(paneId)) return;
+
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+function summarizeViaSessionFileSpark(sessionFile: string): string | null {
+  const transcriptLines = collectTranscriptLines(sessionFile);
+  if (transcriptLines.length === 0) return null;
+
+  const transcript = transcriptLines.join("\n");
+  const result = inference(
+    TRANSCRIPT_SUMMARY_PROMPT,
+    `Session transcript excerpt:\n\n${transcript}`,
+    "fast",
+    SUMMARY_TIMEOUT_SEC,
+    { model: CODEX_MODELS.spark },
+  );
+
+  if (result.success && result.output && result.output.trim() && !looksLikeBadSummary(result.output)) {
+    return result.output.trim();
+  }
+
+  logWarn(
+    "codex-capture",
+    `Session-file Spark summary failed: ${result.error ?? "empty or low-signal output"}`,
+  );
+  return null;
+}
+
+async function summarizeViaResume(sessionId: string): Promise<string | null> {
+  const outputFile = path.join(os.tmpdir(), `codex-resume-summary-${Date.now()}-${process.pid}.txt`);
+
+  const result = await execFileAsync(
+    "codex",
+    [
+      "exec",
+      "resume",
+      sessionId,
+      RESUME_SUMMARY_PROMPT,
+      "--json",
+      "--model",
+      CODEX_MODELS.spark,
+      "--output-last-message",
+      outputFile,
+    ],
+    { timeout: RESUME_TIMEOUT_MS },
+  );
+
+  const summary = readTextIfExists(outputFile);
+  safeCleanup(outputFile);
+
+  if (summary && !looksLikeBadSummary(summary)) return summary;
+  logWarn("codex-capture", `codex exec resume failed for ${sessionId}: exit=${result.exitCode}, stderr=${result.stderr.trim() || "none"}`);
+  return null;
+}
+
+function summarizeFromSessionFileFallback(sessionFile: string): string | null {
+  const lines = collectTranscriptLines(sessionFile).slice(-12);
+  if (lines.length === 0) return null;
+  return `Codex session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
+}
+
+async function main(): Promise<void> {
+  const [paneId, sessionId, sessionFile] = process.argv.slice(2);
+
+  if (!paneId) {
+    console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+    return;
+  }
+
+  await waitForPaneClose(paneId);
+
+  const transcriptSummary = summarizeViaSessionFileSpark(sessionFile ?? "");
+  if (transcriptSummary) {
+    console.log(transcriptSummary);
+    return;
+  }
+
+  if (sessionId) {
+    const resumeSummary = await summarizeViaResume(sessionId);
+    if (resumeSummary) {
+      console.log(resumeSummary);
+      return;
+    }
+  }
+
+  const fallback = summarizeFromSessionFileFallback(sessionFile ?? "");
+  if (fallback) {
+    console.log(fallback);
+    return;
+  }
+
+  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+}
+
+main().catch((error) => {
+  logWarn("codex-capture", `watch-codex failed: ${String(error)}`);
+  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+  process.exit(0);
+});

package/dist/templates/cc-native/_cc-native/lib-ts/cli-output-parser.ts

@@ -1,144 +1,20 @@
 /**
- * Unified Claude CLI output parser.
- * Deduplicates identical logic from orchestrator.ts and reviewers/agent.ts.
- * See cc-native-plan-review-spec.md §4.6
+ * CC-native wrapper around shared structured-output parsing.
+ * Keeps existing import surface stable for provider implementations.
  */
 
-import { parseJsonMaybe } from "./json-parser.js";
-import { logDebug, logError, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { parseStructuredOutput } from "../../_shared/lib-ts/agent-exec/structured-output.js";
 
 /**
- * Parse Claude CLI JSON output, handling various formats.
- *
- * Claude CLI can output in several formats:
- * - Direct structured_output dict
- * - Assistant message with StructuredOutput tool use
- * - List of events with assistant messages
- * - Raw text with embedded JSON (heuristic fallback)
- *
- * @param raw - Raw stdout from Claude CLI
- * @param requireFields - Optional fields to validate in heuristic fallback
- * @returns Parsed JSON dict or null if parsing failed
+ * Parse CLI JSON output into a structured object.
+ * Delegates to shared parser with cc-native logging tag.
  */
 export function parseCliOutput(
   raw: string,
   requireFields?: string[],
 ): null | Record<string, unknown> {
-  try {
-    const result: unknown = JSON.parse(raw);
-
-    if (result !== null && typeof result === "object" && !Array.isArray(result)) {
-      const dict = result as Record<string, unknown>;
-
-      // Strategy 1: Direct structured_output key
-      if ("structured_output" in dict) {
-        logDebug("cli_parser", "Found structured_output in root dict");
-        return dict.structured_output as Record<string, unknown>;
-      }
-
-      // Strategy 1.5: Session result envelope (type: "result")
-      // When the model fails to call StructuredOutput, the CLI returns a
-      // session metadata object with type/subtype/duration_ms/usage/etc.
-      // but no structured_output key. Check for the `result` text field
-      // (model may have written review as text) and for error states.
-      if (dict.type === "result" || ("duration_ms" in dict && "session_id" in dict)) {
-        if (dict.is_error === true || (Array.isArray(dict.errors) && (dict.errors as unknown[]).length > 0)) {
-          logWarn("cli_parser", `CLI returned error result: ${JSON.stringify(dict.errors ?? "is_error=true")}`);
-          return null;
-        }
-        if (typeof dict.result === "string" && dict.result) {
-          logDebug("cli_parser", "Found result text in session envelope, attempting JSON extraction");
-          const extracted = parseJsonMaybe(dict.result as string, requireFields);
-          if (extracted) return extracted;
-          logWarn("cli_parser", "Session envelope result text contained no extractable JSON");
-        }
-        logDebug("cli_parser", "Session result envelope with no structured_output or extractable result");
-        return null;
-      }
-
-      // Strategy 2: Assistant message with StructuredOutput tool use
-      if (dict.type === "assistant") {
-        const message = dict.message as Record<string, unknown> | undefined;
-        const content = message?.content;
-        if (Array.isArray(content)) {
-          for (const item of content) {
-            if (
-              item !== null &&
-              typeof item === "object" &&
-              (item as Record<string, unknown>).name === "StructuredOutput"
-            ) {
-              logDebug(
-                "cli_parser",
-                "Found StructuredOutput in assistant message content",
-              );
-              return (item as Record<string, unknown>).input as Record<
-                string,
-                unknown
-              >;
-            }
-          }
-        }
-
-        logDebug(
-          "cli_parser",
-          "Assistant message found but no StructuredOutput tool use in content",
-        );
-      }
-    } else if (Array.isArray(result)) {
-      // Strategy 3: List of events with assistant messages
-      logDebug(
-        "cli_parser",
-        `Received list of ${(result as unknown[]).length} events, searching for assistant message`,
-      );
-      for (let i = 0; i < (result as unknown[]).length; i++) {
-        const event = (result as unknown[])[i];
-        if (event === null || typeof event !== "object") continue;
-
-        const dict = event as Record<string, unknown>;
-        if (dict.type === "assistant") {
-          const message = dict.message as Record<string, unknown> | undefined;
-          const content = message?.content;
-          if (Array.isArray(content)) {
-            for (const item of content) {
-              if (
-                item !== null &&
-                typeof item === "object" &&
-                (item as Record<string, unknown>).name === "StructuredOutput"
-              ) {
-                logDebug(
-                  "cli_parser",
-                  `Found StructuredOutput in event[${i}] assistant message`,
-                );
-                return (item as Record<string, unknown>).input as Record<
-                  string,
-                  unknown
-                >;
-              }
-            }
-          }
-        }
-      }
-
-      logDebug(
-        "cli_parser",
-        "No StructuredOutput found in any assistant message in event list",
-      );
-    }
-  } catch (error: unknown) {
-    if (error instanceof SyntaxError) {
-      logWarn("cli_parser", `JSON decode error: ${error.message}`);
-    } else {
-      logError(
-        "cli_parser",
-        `Unexpected error during structured parsing: ${error}`,
-      );
-    }
-  }
-
-  // Strategy 4: Heuristic {…} extraction fallback
-  logDebug(
-    "cli_parser",
-    "No structured output found, falling back to heuristic JSON extraction",
-  );
-  return parseJsonMaybe(raw, requireFields);
+  return parseStructuredOutput(raw, {
+    requireFields,
+    loggerTag: "cli_parser",
+  });
 }