@awak-app/simy-cli 0.1.1 → 0.1.3

package/src/provider-stream.js

@@ -0,0 +1,327 @@
+import { stripVTControlCharacters } from "node:util";
+
+const MAX_LINE_CHARS = 2_000;
+const STRUCTURED_MARKERS = ["SIMY_RESULT_JSON:", "SIMY_AUDIT_JSON:"];
+const CODEX_MCP_AUTH_WARNING =
+  "[Codex] MCP warning: optional connector authorization expired; coding continues.";
+
+export function createProviderStreamDecoder({ backend, stream = "stdout", onLine, onUsage }) {
+  let pending = "";
+  let previous = "";
+  let model = "";
+
+  function consume(value) {
+    const text = stripVTControlCharacters(String(value || "")).trim();
+    if (!text || STRUCTURED_MARKERS.some((marker) => text.startsWith(marker))) return;
+
+    let event;
+    try {
+      event = JSON.parse(text);
+    } catch {
+      emit(formatPlainLine(backend, stream, text));
+      return;
+    }
+
+    model = providerModel(backend, event) || model;
+    const usage = extractProviderTokenUsage(backend, event, { model });
+    if (usage && onUsage) onUsage(usage);
+
+    for (const line of formatProviderEvent(backend, event)) emit(line);
+  }
+
+  function emit(line) {
+    const text = cleanLine(line);
+    if (!text || text === previous) return;
+    previous = text;
+    onLine(text);
+  }
+
+  return {
+    push(chunk) {
+      pending += String(chunk || "");
+      const lines = pending.split(/\r?\n/);
+      pending = lines.pop() || "";
+      for (const line of lines) consume(line);
+    },
+    flush() {
+      consume(pending);
+      pending = "";
+    },
+  };
+}
+
+export function extractProviderTokenUsage(backend, event, { model = "" } = {}) {
+  if (!event || typeof event !== "object") return null;
+  if (backend === "claude") {
+    if (event.type !== "result") return null;
+    return normalizeClaudeUsage(event.usage, model || event.model);
+  }
+  if (event.type !== "turn.completed") return null;
+  return normalizeCodexUsage(event.usage, model || event.model);
+}
+
+export function formatProviderEvent(backend, event) {
+  if (!event || typeof event !== "object") return [];
+  return backend === "claude" ? formatClaudeEvent(event) : formatCodexEvent(event);
+}
+
+export function isNonFatalProviderDiagnostic(line) {
+  return line === CODEX_MCP_AUTH_WARNING;
+}
+
+function formatCodexEvent(event) {
+  const prefix = "[Codex]";
+  if (event.type === "thread.started") {
+    return [`${prefix} session started${shortIdentifier(event.thread_id)}`];
+  }
+  if (event.type === "turn.started") return [`${prefix} turn started`];
+  if (event.type === "turn.completed") {
+    return [`${prefix} completed${formatUsage(event.usage)}`];
+  }
+  if (event.type === "turn.failed" || event.type === "error") {
+    return [`${prefix} error: ${errorMessage(event)}`];
+  }
+  if (event.type !== "item.started" && event.type !== "item.completed") return [];
+
+  const item = event.item && typeof event.item === "object" ? event.item : {};
+  const phase = event.type === "item.started" ? "started" : "completed";
+  switch (item.type) {
+    case "agent_message":
+      return contentLines(prefix, "assistant", item.text || item.message);
+    case "reasoning":
+      return contentLines(prefix, "reasoning", item.text || item.summary);
+    case "command_execution":
+      return formatCodexCommand(prefix, item, phase);
+    case "file_change":
+      return formatFileChanges(prefix, item);
+    case "mcp_tool_call":
+      return [`${prefix} tool ${phase}: ${toolName(item)}`];
+    case "web_search":
+      return [`${prefix} web search ${phase}: ${cleanLine(item.query || "search")}`];
+    case "todo_list":
+      return [`${prefix} plan updated`];
+    case "error":
+      return [`${prefix} error: ${cleanLine(item.message || "provider item failed")}`];
+    default:
+      return item.type ? [`${prefix} ${cleanLine(item.type)} ${phase}`] : [];
+  }
+}
+
+function formatClaudeEvent(event) {
+  const prefix = "[Claude Code]";
+  if (event.type === "system" && event.subtype === "init") {
+    const model = cleanLine(event.model || "");
+    return [`${prefix} session started${model ? ` | ${model}` : ""}`];
+  }
+  if (event.type === "system" && event.subtype === "hook_response") {
+    const warning = cleanLine(event.stderr || "");
+    return warning ? [`${prefix} hook warning: ${warning}`] : [];
+  }
+  if (event.type === "assistant") {
+    return formatClaudeContent(prefix, event.message?.content);
+  }
+  if (event.type === "user") {
+    return formatClaudeToolResults(prefix, event.message?.content);
+  }
+  if (event.type === "result") {
+    if (event.is_error) return [`${prefix} error: ${cleanLine(event.result || event.subtype)}`];
+    const turns = Number.isInteger(event.num_turns) ? ` | ${event.num_turns} turn(s)` : "";
+    const duration = Number.isFinite(event.duration_ms)
+      ? ` | ${(event.duration_ms / 1_000).toFixed(1)}s`
+      : "";
+    return [`${prefix} completed${turns}${duration}${formatUsage(event.usage)}`];
+  }
+  if (event.type === "rate_limit_event") return [`${prefix} rate limit status updated`];
+  return [];
+}
+
+function formatCodexCommand(prefix, item, phase) {
+  const command = cleanLine(item.command || item.cmd || "command");
+  if (phase === "started") return [`${prefix} command started: ${command}`];
+  const exitCode = Number.isInteger(item.exit_code) ? ` (exit ${item.exit_code})` : "";
+  const lines = [`${prefix} command completed${exitCode}: ${command}`];
+  const output = item.aggregated_output || item.output || "";
+  if (String(output).trim()) lines.push(...contentLines(prefix, "output", output).slice(-6));
+  return lines;
+}
+
+function formatFileChanges(prefix, item) {
+  const changes = Array.isArray(item.changes) ? item.changes : [];
+  const paths = changes
+    .map((change) => cleanLine(change?.path || change?.file || ""))
+    .filter(Boolean);
+  if (paths.length > 0) return [`${prefix} files changed: ${paths.join(", ")}`];
+  return [`${prefix} file changes completed`];
+}
+
+function formatClaudeContent(prefix, content) {
+  const blocks = Array.isArray(content) ? content : [];
+  const lines = [];
+  for (const block of blocks) {
+    if (block?.type === "text") lines.push(...contentLines(prefix, "assistant", block.text));
+    if (block?.type === "thinking") lines.push(...contentLines(prefix, "reasoning", block.thinking));
+    if (block?.type === "tool_use") {
+      const detail = toolInputSummary(block.input);
+      lines.push(`${prefix} tool started: ${cleanLine(block.name || "tool")}${detail}`);
+    }
+  }
+  return lines;
+}
+
+function formatClaudeToolResults(prefix, content) {
+  const blocks = Array.isArray(content) ? content : [];
+  const lines = [];
+  for (const block of blocks) {
+    if (block?.type !== "tool_result") continue;
+    const status = block.is_error ? "failed" : "completed";
+    lines.push(`${prefix} tool ${status}${shortIdentifier(block.tool_use_id)}`);
+    const output = toolResultText(block.content);
+    if (output) {
+      lines.push(
+        ...contentLines(prefix, block.is_error ? "error" : "output", output).slice(-6),
+      );
+    }
+  }
+  return lines;
+}
+
+function contentLines(prefix, label, value) {
+  return String(value || "")
+    .split(/\r?\n/)
+    .map((line) => cleanLine(line))
+    .filter(Boolean)
+    .map((line) => `${prefix} ${label}: ${line}`);
+}
+
+function formatPlainLine(backend, stream, value) {
+  const prefix = backend === "claude" ? "[Claude Code]" : "[Codex]";
+  if (backend === "codex" && isCodexMcpAuthorizationDiagnostic(value)) {
+    return CODEX_MCP_AUTH_WARNING;
+  }
+  const diagnostic = String(value).match(
+    /^\S+\s+(WARN|ERROR|INFO)\s+([\w.-]+(?:::[\w.-]+)*):\s*(.*)$/,
+  );
+  if (diagnostic) {
+    const level = diagnostic[1].toLowerCase();
+    return `${prefix} ${level}: ${diagnostic[3] || diagnostic[2]}`;
+  }
+  return stream === "stderr" ? `${prefix} stderr: ${value}` : `${prefix} ${value}`;
+}
+
+function isCodexMcpAuthorizationDiagnostic(value) {
+  const text = String(value || "");
+  return (
+    /(?:rmcp::|codex_mcp::)/.test(text) &&
+    /(?:invalid_grant|AuthorizationRequired|OAuth authorization required)/i.test(text)
+  );
+}
+
+function toolResultText(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value
+    .map((item) => (typeof item === "string" ? item : item?.text || item?.content || ""))
+    .filter(Boolean)
+    .join("\n");
+}
+
+function formatUsage(usage) {
+  if (!usage || typeof usage !== "object") return "";
+  const input = integer(usage.input_tokens ?? usage.inputTokens);
+  const output = integer(usage.output_tokens ?? usage.outputTokens);
+  const cached = integer(usage.cached_input_tokens ?? usage.cache_read_input_tokens);
+  const parts = [];
+  if (input !== null) parts.push(`${input.toLocaleString("en-US")} in`);
+  if (output !== null) parts.push(`${output.toLocaleString("en-US")} out`);
+  if (cached !== null) parts.push(`${cached.toLocaleString("en-US")} cached`);
+  return parts.length > 0 ? ` | ${parts.join(" / ")}` : "";
+}
+
+function normalizeCodexUsage(usage, model) {
+  if (!usage || typeof usage !== "object") return null;
+  const tokensIn = tokenNumber(usage.input_tokens ?? usage.inputTokens);
+  const tokensOut = tokenNumber(usage.output_tokens ?? usage.outputTokens);
+  if (tokensIn + tokensOut <= 0) return null;
+  const cached = tokenNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+  return compactUsage({
+    tokens_in: tokensIn,
+    tokens_out: tokensOut,
+    total_tokens: tokensIn + tokensOut,
+    cached_input_tokens: cached,
+    model: cleanLine(model || usage.model || ""),
+  });
+}
+
+function normalizeClaudeUsage(usage, model) {
+  if (!usage || typeof usage !== "object") return null;
+  const uncached = tokenNumber(usage.input_tokens ?? usage.inputTokens);
+  const cacheRead = tokenNumber(
+    usage.cache_read_input_tokens ?? usage.cacheReadInputTokens,
+  );
+  const cacheCreation = tokenNumber(
+    usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens,
+  );
+  const tokensOut = tokenNumber(usage.output_tokens ?? usage.outputTokens);
+  const tokensIn = uncached + cacheRead + cacheCreation;
+  if (tokensIn + tokensOut <= 0) return null;
+  return compactUsage({
+    tokens_in: tokensIn,
+    tokens_out: tokensOut,
+    total_tokens: tokensIn + tokensOut,
+    uncached_input_tokens: uncached,
+    cached_input_tokens: cacheRead,
+    cache_creation_input_tokens: cacheCreation,
+    model: cleanLine(model || usage.model || ""),
+  });
+}
+
+function compactUsage(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== "" && item !== null && item !== undefined),
+  );
+}
+
+function providerModel(backend, event) {
+  if (backend === "claude" && event.type === "system" && event.subtype === "init") {
+    return cleanLine(event.model || "");
+  }
+  return cleanLine(event.model || "");
+}
+
+function tokenNumber(value) {
+  return Number.isFinite(value) && value >= 0 ? Math.round(value) : 0;
+}
+
+function toolName(item) {
+  const server = cleanLine(item.server || item.server_name || "");
+  const tool = cleanLine(item.tool || item.tool_name || item.name || "tool");
+  return server ? `${server}.${tool}` : tool;
+}
+
+function toolInputSummary(input) {
+  if (!input || typeof input !== "object") return "";
+  const value = input.command || input.file_path || input.path || input.query || input.pattern;
+  const summary = cleanLine(value || "");
+  return summary ? `: ${summary}` : "";
+}
+
+function errorMessage(event) {
+  const error = event.error;
+  if (typeof error === "string") return cleanLine(error);
+  return cleanLine(error?.message || event.message || "provider turn failed");
+}
+
+function shortIdentifier(value) {
+  const text = cleanLine(value || "");
+  return text ? ` | ${text.slice(0, 8)}` : "";
+}
+
+function integer(value) {
+  return Number.isInteger(value) ? value : null;
+}
+
+function cleanLine(value) {
+  const text = stripVTControlCharacters(String(value || "")).replace(/\s+/g, " ").trim();
+  if (text.length <= MAX_LINE_CHARS) return text;
+  return `${text.slice(0, MAX_LINE_CHARS - 3)}...`;
+}

package/src/repository-inventory.js

@@ -0,0 +1,216 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, readdir, realpath, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+import { normalizeGitHubRemote } from "./workspace-context.js";
+
+const execFileAsync = promisify(execFile);
+const INVENTORY_VERSION = 1;
+const DEFAULT_MAX_DEPTH = 12;
+const DEFAULT_MAX_REPOSITORIES = 1_000;
+const SKIPPED_DIRECTORIES = new Set([
+  ".git",
+  ".cache",
+  ".npm",
+  ".pnpm-store",
+  ".Trash",
+  ".yarn",
+  "Library",
+  "node_modules",
+  "vendor",
+]);
+
+export function defaultRepositoryScanRoot() {
+  return homedir();
+}
+
+export function repositoryInventoryPath(inventoryRoot = defaultInventoryRoot()) {
+  return join(inventoryRoot, "repository-inventory.json");
+}
+
+export async function scanGitRepositories(
+  requestedRoot,
+  { maxDepth = DEFAULT_MAX_DEPTH, maxRepositories = DEFAULT_MAX_REPOSITORIES } = {},
+) {
+  const root = await realpath(resolve(String(requestedRoot || defaultRepositoryScanRoot())));
+  const repositories = [];
+  const visited = new Set();
+  const pending = [{ directory: root, depth: 0 }];
+
+  while (pending.length > 0 && repositories.length < maxRepositories) {
+    const current = pending.shift();
+    if (!current || visited.has(current.directory)) continue;
+    visited.add(current.directory);
+
+    let entries;
+    try {
+      entries = await readdir(current.directory, { withFileTypes: true });
+    } catch (error) {
+      if (isSkippableFilesystemError(error)) continue;
+      throw error;
+    }
+
+    if (entries.some((entry) => entry.name === ".git")) {
+      const repository = await inspectGitRepository(current.directory);
+      if (repository) repositories.push(repository);
+      continue;
+    }
+    if (current.depth >= maxDepth) continue;
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || shouldSkipDirectory(entry.name)) {
+        continue;
+      }
+      pending.push({
+        directory: join(current.directory, entry.name),
+        depth: current.depth + 1,
+      });
+    }
+  }
+
+  return {
+    root,
+    scannedAt: new Date().toISOString(),
+    repositories: mergeRepositoryInventory(repositories),
+    truncated: repositories.length >= maxRepositories,
+  };
+}
+
+export async function readRepositoryInventory(inventoryRoot = defaultInventoryRoot()) {
+  try {
+    const parsed = JSON.parse(await readFile(repositoryInventoryPath(inventoryRoot), "utf8"));
+    if (parsed?.version !== INVENTORY_VERSION) return emptyInventory();
+    return {
+      version: INVENTORY_VERSION,
+      authorizedRoots: uniqueStrings(parsed.authorized_roots),
+      repositories: mergeRepositoryInventory(parsed.repositories),
+      scannedAt: typeof parsed.scanned_at === "string" ? parsed.scanned_at : null,
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT" || error instanceof SyntaxError) return emptyInventory();
+    throw error;
+  }
+}
+
+export async function writeRepositoryInventory(
+  { authorizedRoots = [], repositories = [], scannedAt = new Date().toISOString() },
+  inventoryRoot = defaultInventoryRoot(),
+) {
+  const target = repositoryInventoryPath(inventoryRoot);
+  await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+  await writeFile(
+    target,
+    `${JSON.stringify(
+      {
+        version: INVENTORY_VERSION,
+        authorized_roots: uniqueStrings(authorizedRoots),
+        scanned_at: scannedAt,
+        repositories: mergeRepositoryInventory(repositories).map((item) => ({
+          repository: item.repository,
+          branch: item.branch,
+          default_branch: item.default_branch,
+          local_path: item.local_path,
+        })),
+      },
+      null,
+      2,
+    )}\n`,
+    { encoding: "utf8", mode: 0o600 },
+  );
+}
+
+export function mergeRepositoryInventory(...inventories) {
+  const byPath = new Map();
+  for (const item of inventories.flat()) {
+    const repository = normalizeGitHubRemote(item?.repository);
+    const localPath = String(item?.local_path || item?.localPath || "").trim();
+    if (!repository || !localPath) continue;
+    byPath.set(resolve(localPath), {
+      repository,
+      branch: String(item?.branch || "").trim() || "dev",
+      default_branch:
+        String(item?.default_branch || item?.defaultBranch || "").trim() || "dev",
+      local_path: resolve(localPath),
+    });
+  }
+  return [...byPath.values()].sort((left, right) =>
+    left.repository.localeCompare(right.repository),
+  );
+}
+
+export function findRepository(inventory, repository) {
+  const expected = normalizeGitHubRemote(repository)?.toLowerCase();
+  if (!expected) return null;
+  return (
+    inventory.find((item) => normalizeGitHubRemote(item?.repository)?.toLowerCase() === expected) ||
+    null
+  );
+}
+
+async function inspectGitRepository(directory) {
+  try {
+    const [{ stdout: root }, { stdout: remote }, { stdout: branch }] = await Promise.all([
+      execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd: directory }),
+      execFileAsync("git", ["remote", "get-url", "origin"], { cwd: directory }),
+      execFileAsync("git", ["branch", "--show-current"], { cwd: directory }),
+    ]);
+    const repository = normalizeGitHubRemote(remote);
+    if (!repository) return null;
+    return {
+      repository,
+      branch: String(branch || "").trim() || "dev",
+      default_branch: await detectDefaultBranch(directory),
+      local_path: String(root || "").trim(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function detectDefaultBranch(directory) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+      { cwd: directory },
+    );
+    const branch = String(stdout || "").trim().replace(/^origin\//, "");
+    if (branch) return branch;
+  } catch {
+    // Fall through to local remote refs for repositories without origin/HEAD.
+  }
+
+  for (const branch of ["dev", "main", "master"]) {
+    try {
+      await execFileAsync("git", ["show-ref", "--verify", `refs/remotes/origin/${branch}`], {
+        cwd: directory,
+      });
+      return branch;
+    } catch {
+      // Try the next conventional default branch.
+    }
+  }
+  return "dev";
+}
+
+function shouldSkipDirectory(name) {
+  return name.startsWith(".") || SKIPPED_DIRECTORIES.has(name);
+}
+
+function isSkippableFilesystemError(error) {
+  return error?.code === "EACCES" || error?.code === "EPERM" || error?.code === "ENOENT";
+}
+
+function uniqueStrings(values) {
+  return [...new Set((Array.isArray(values) ? values : []).map(String).filter(Boolean))];
+}
+
+function emptyInventory() {
+  return { version: INVENTORY_VERSION, authorizedRoots: [], repositories: [], scannedAt: null };
+}
+
+function defaultInventoryRoot() {
+  return process.env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+}

package/src/run-registry.js

@@ -0,0 +1,44 @@
+import { EventEmitter } from "node:events";
+
+export class LocalRunRegistry extends EventEmitter {
+  #runs = new Map();
+  #listeners = new Map();
+
+  create(run) {
+    if (this.#runs.has(run.id)) throw new Error(`Run ${run.id} already exists.`);
+    this.#runs.set(run.id, run);
+    const listener = (event) => {
+      this.emit("event", { run, event });
+      this.emit("change", this.list());
+    };
+    this.#listeners.set(run.id, listener);
+    run.emitter.on("event", listener);
+    this.emit("event", { run, event: { type: "created", run_id: run.id } });
+    this.emit("change", this.list());
+    return run;
+  }
+
+  get(runId) {
+    return this.#runs.get(runId) ?? null;
+  }
+
+  has(runId) {
+    return this.#runs.has(runId);
+  }
+
+  list() {
+    return [...this.#runs.values()].sort((left, right) => {
+      const leftTime = Date.parse(left.snapshot?.updated_at || left.startedAt || 0) || 0;
+      const rightTime = Date.parse(right.snapshot?.updated_at || right.startedAt || 0) || 0;
+      return rightTime - leftTime;
+    });
+  }
+
+  close() {
+    for (const [runId, listener] of this.#listeners) {
+      this.#runs.get(runId)?.emitter.off("event", listener);
+    }
+    this.#listeners.clear();
+    this.removeAllListeners();
+  }
+}