@hizliemre/horse-code 0.2.0 → 0.3.1

package/dist/chunk-G45RWL7S.js

@@ -0,0 +1,289 @@
+// src/agents/cli-auth.ts
+import { spawnSync } from "child_process";
+
+// src/agents/cli-agent.ts
+import { spawn } from "child_process";
+var CLI_KINDS = ["claude", "codex", "grok", "zai"];
+function cliBinary(kind) {
+  return kind === "zai" ? "claude" : kind;
+}
+var CLI_ERROR_UNSPOKEN = "the CLI reported an error";
+function cliArgs(kind, prompt, extra = []) {
+  if (kind === "claude" || kind === "zai") {
+    return ["--output-format", "stream-json", "--verbose", ...extra, "-p", "--", prompt];
+  }
+  if (kind === "codex") {
+    return ["exec", "--json", "--skip-git-repo-check", ...extra, "--", prompt];
+  }
+  return ["--output-format", "streaming-messages-json", ...extra, `--single=${prompt}`];
+}
+function decodeClaudeEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = e.type;
+  if (type === "rate_limit_event") {
+    const info = e.rate_limit_info ?? {};
+    const status = String(info.status ?? "unknown");
+    const raw = info.unifiedWindows ?? {};
+    const windows = {};
+    for (const [name, w] of Object.entries(raw)) windows[name] = w?.utilization ?? 0;
+    const quota = {
+      status,
+      windows,
+      ...typeof info.resetsAt === "number" ? { resetsAt: info.resetsAt } : {}
+    };
+    return status.startsWith("allowed") ? { quota } : {
+      quota,
+      /**
+       * The reset time rides along, as an ISO instant rather than prose.
+       *
+       * A spent five-hour window reopens; without saying when, the only safe bench is "the rest of the
+       * run", which on a ten-hour board writes off a subscription for hours after it recovered. The
+       * gateway's wordings said "reset after 4h" and nothing ever parsed them — see `quotaResetAt`.
+       */
+      rateLimited: `${status} \u2014 ${describeWindows(windows)}` + (quota.resetsAt ? ` (resets ${new Date(quota.resetsAt * 1e3).toISOString()})` : "")
+    };
+  }
+  if (type === "assistant") {
+    const msg = e.message;
+    const parts = Array.isArray(msg?.content) ? msg.content : [];
+    const text = parts.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("");
+    const tool = parts.find((b) => typeof b === "object" && b !== null && b.type === "tool_use");
+    return {
+      ...text ? { text } : {},
+      ...msg?.model ? { served: msg.model } : {},
+      ...tool ? { tool: { name: tool.name, ...targetOf(tool.input) ? { target: targetOf(tool.input) } : {} } } : {}
+    };
+  }
+  if (type === "user") {
+    const parts = e.message?.content;
+    const failed = (Array.isArray(parts) ? parts : []).find(
+      (b) => typeof b === "object" && b !== null && b.type === "tool_result" && b.is_error === true
+    );
+    return failed ? { tool: { name: "tool", ok: false } } : void 0;
+  }
+  if (type === "result") {
+    const u = e.usage ?? {};
+    const cost = e.total_cost_usd;
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cache_read_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        ...cost !== void 0 ? { costUsd: cost } : {}
+      },
+      ...e.subtype === "error_during_execution" ? { error: String(e.result ?? CLI_ERROR_UNSPOKEN) } : {}
+    };
+  }
+  return void 0;
+}
+function decodeCodexEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = String(e.type ?? "");
+  if (/rate.?limit/i.test(type)) return { rateLimited: String(e.message ?? "rate limited by the CLI") };
+  if (type === "item.completed") {
+    const item = e.item;
+    if (item?.type === "agent_message" && item.text) return { text: item.text };
+    if (item?.type && item.type !== "agent_message") {
+      const changes = item.changes;
+      const first = Array.isArray(changes) ? changes.find((c) => typeof c?.path === "string")?.path : void 0;
+      const more = Array.isArray(changes) && changes.length > 1 ? ` +${changes.length - 1}` : "";
+      return {
+        tool: {
+          name: item.name ?? item.type,
+          ...first ? { target: `${first}${more}` } : {}
+        }
+      };
+    }
+    return void 0;
+  }
+  if (type === "turn.completed") {
+    const u = e.usage ?? {};
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cached_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_write_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0
+      }
+    };
+  }
+  if (type === "turn.failed" || type === "error") {
+    return { error: String(e.message ?? "codex reported an error") };
+  }
+  return void 0;
+}
+function describeWindows(windows) {
+  const parts = Object.entries(windows).map(([k, v]) => `${k} ${Math.round(v * 100)}%`);
+  return parts.length ? parts.join(", ") : "no window reported";
+}
+var SYNTHETIC = "<synthetic>";
+function targetOf(input) {
+  for (const k of ["file_path", "path", "filePath", "notebook_path"]) {
+    const v = input?.[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return void 0;
+}
+function makeStreamReader(decode, onEvent) {
+  let pending = "";
+  const drain = (upToNewline) => {
+    const lines = pending.split("\n");
+    pending = upToNewline ? lines.pop() ?? "" : "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const ev = decode(line);
+      if (ev) onEvent(ev);
+    }
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      drain(true);
+    },
+    end() {
+      if (pending.trim()) drain(false);
+    }
+  };
+}
+function reportedError(decoded, stderr, exitCode) {
+  if (decoded && decoded !== CLI_ERROR_UNSPOKEN) return decoded;
+  const spoken = exitCode !== 0 ? stderr.trim().slice(0, 500) : "";
+  return spoken || decoded || void 0;
+}
+async function runCliAgent(run) {
+  const decode = run.kind === "codex" ? decodeCodexEvent : decodeClaudeEvent;
+  const args = cliArgs(run.kind, run.prompt, run.args ?? []);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cliBinary(run.kind), args, {
+        cwd: run.cwd,
+        signal: run.signal,
+        stdio: ["ignore", "pipe", "pipe"],
+        ...run.configDir ? { env: { ...process.env, ...profileEnv(run.kind, run.configDir) } } : {}
+      });
+    } catch (e) {
+      resolve({ text: "", error: e instanceof Error ? e.message : String(e), exitCode: -1 });
+      return;
+    }
+    let text = "";
+    let usage;
+    let rateLimited;
+    let served;
+    let quota;
+    let error;
+    let stderr = "";
+    const reader = makeStreamReader(decode, (ev) => {
+      if (ev.text) text += ev.text;
+      if (ev.usage) usage = ev.usage;
+      if (ev.rateLimited) rateLimited = ev.rateLimited;
+      if (ev.served) served = ev.served;
+      if (ev.quota) quota = ev.quota;
+      if (ev.error) error = ev.error;
+      run.onEvent?.(ev);
+    });
+    child.stdout?.on("data", (d) => reader.push(d.toString()));
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (e) => resolve({ text, ...usage ? { usage } : {}, error: e.message, exitCode: -1 }));
+    child.on("close", (code) => {
+      reader.end();
+      const reported = reportedError(error, stderr, code ?? -1);
+      resolve({
+        text,
+        ...usage ? { usage } : {},
+        ...rateLimited ? { rateLimited } : {},
+        ...quota ? { quota } : {},
+        ...served ? { served } : {},
+        ...reported ? { error: reported } : {},
+        exitCode: code ?? -1
+      });
+    });
+  });
+}
+
+// src/agents/cli-auth.ts
+function profileEnv(kind, configDir) {
+  if (!configDir) return {};
+  if (kind === "claude" || kind === "zai") return { CLAUDE_CONFIG_DIR: configDir };
+  if (kind === "codex") return { CODEX_HOME: configDir };
+  return { GROK_HOME: configDir };
+}
+function readAuthStatus(kind, out) {
+  if (kind === "grok") {
+    const m = /you are logged in with\s+(.+)/i.exec(out);
+    if (!m) return { loggedIn: false };
+    const plan = m[1].trim().replace(/\.$/, "");
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  if (kind === "codex") {
+    const m = /logged in(?: using (.+))?/i.exec(out);
+    if (!m || /not logged in/i.test(out)) return { loggedIn: false };
+    const plan = m[1]?.trim();
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  try {
+    const j = JSON.parse(out);
+    if (!j.loggedIn) return { loggedIn: false };
+    return {
+      loggedIn: true,
+      ...j.email ? { email: j.email } : {},
+      ...j.subscriptionType ? { plan: j.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: false };
+  }
+}
+function statusArgs(kind) {
+  if (kind === "claude" || kind === "zai") return ["auth", "status"];
+  if (kind === "codex") return ["login", "status"];
+  return ["models"];
+}
+function loginArgs(kind) {
+  return kind === "claude" ? ["auth", "login"] : ["login"];
+}
+function checkProfile(kind, configDir) {
+  if (kind === "zai" && !configDir) return { loggedIn: false };
+  const r = spawnSync(cliBinary(kind), statusArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    encoding: "utf8",
+    // A status check that hangs must not hang the startup summary with it.
+    timeout: 2e4
+  });
+  if (r.error) return { loggedIn: false };
+  return readAuthStatus(kind, `${r.stdout ?? ""}${r.stderr ?? ""}`);
+}
+function runLogin(kind, configDir) {
+  if (kind === "zai") {
+    return { ok: false, error: "z.ai has no sign-in \u2014 a profile is connected by writing its settings file" };
+  }
+  const r = spawnSync(cliBinary(kind), loginArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    stdio: "inherit"
+  });
+  if (r.error) {
+    const e = r.error;
+    return e.code === "ENOENT" ? { ok: false, error: `\`${kind}\` is not installed, or not on PATH` } : { ok: false, error: e.message };
+  }
+  return { ok: r.status === 0 };
+}
+
+export {
+  checkProfile,
+  runLogin,
+  CLI_KINDS,
+  SYNTHETIC,
+  runCliAgent
+};

package/dist/{chunk-AE36LLL2.js → chunk-JLWQCA7B.js}

@@ -1160,212 +1160,6 @@ async function runToCompletion(opts) {
   return last;
 }
 
-// src/tools/registry.ts
-import { z } from "zod";
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  /**
-   * Registered and callable, but whose SCHEMA is withheld until something asks for it.
-   *
-   * A schema is paid for on every turn, whether or not the tool is ever used. Measured across twelve runs:
-   * 49 MCP tool schemas came to 86,620 characters (~21,655 tokens), 242 calls carried them, and that is
-   * ~5.2M of the 21.7M input tokens billed — 24% of everything — for FIVE tool calls, of two distinct tools.
-   * The catalogue that names them costs 900 characters (see MAX_TOOL_NOTE_CHARS); it is the schemas that are
-   * expensive, and a schema nobody is about to use buys nothing.
-   */
-  deferred = /* @__PURE__ */ new Set();
-  /** Bumped by anything that changes what `schemas()` would return, so the derivation can be cached. */
-  version = 0;
-  cached;
-  register(tool) {
-    this.tools.set(tool.name, tool);
-    this.deferred.delete(tool.name);
-    this.version++;
-  }
-  /** Callable by name from the moment it is registered; sent to the model only once {@link surface}d. */
-  registerDeferred(tool) {
-    this.tools.set(tool.name, tool);
-    this.deferred.add(tool.name);
-    this.version++;
-  }
-  /**
-   * Hands over the schemas for these names, from the next turn onward.
-   *
-   * Returns the ones that were actually withheld, so a caller can say what it just made available and stay
-   * quiet about what was already there.
-   */
-  surface(names) {
-    const opened = names.filter((n) => this.deferred.has(n));
-    for (const n of opened) this.deferred.delete(n);
-    if (opened.length) this.version++;
-    return opened;
-  }
-  /** Everything still withheld — what a search tool searches. */
-  deferredTools() {
-    return [...this.deferred].map((n) => this.tools.get(n)).filter((t) => t !== void 0);
-  }
-  /**
-   * A withheld tool is still CALLABLE.
-   *
-   * A model that reads the catalogue and calls the name straight off is right, and refusing it to enforce a
-   * search step would spend a turn teaching it a rule that exists for our benefit, not its.
-   */
-  get(name) {
-    return this.tools.get(name);
-  }
-  list() {
-    return [...this.tools.values()];
-  }
-  /**
-   * Tool schemas to send to the LLM: zod parameters → JSON Schema (zod 4 native). Withheld ones are omitted.
-   *
-   * …and so is a tool that has withdrawn itself. `Tool.broken` was documented as being read "where tools are
-   * OFFERED, so a broken one stops being handed to fresh agents" — and only `find_tool` ever read it, which
-   * covers the deferred tools and not the ones already on the list.
-   *
-   * Measured on one run: `mcp__angular-cli__list_projects` answered its first caller with a reply that failed
-   * its own declared output schema and withdrew itself. It was then offered to seventeen more agents, who
-   * called it twenty-eight more times. Every one of those was answered instantly, without touching the
-   * server — and still cost a whole model turn to learn what the run already knew.
-   */
-  schemas() {
-    const withdrawn = this.list().reduce((n, t) => n + (t.broken === void 0 ? 0 : 1), 0);
-    if (this.cached?.version === this.version && this.cached.withdrawn === withdrawn) return this.cached.schemas;
-    const schemas = this.list().filter((t) => !this.deferred.has(t.name) && t.broken === void 0).map((t) => ({
-      name: t.name,
-      description: t.description,
-      // MCP tools already carry a JSON Schema; everyone else derives it from their zod parameters.
-      parameters: t.rawSchema ?? z.toJSONSchema(t.parameters, { target: "draft-7" })
-    }));
-    this.cached = { version: this.version, withdrawn, schemas };
-    return schemas;
-  }
-};
-
-// src/core/types.ts
-var DEADLINE_MESSAGE = "the model did not answer within its deadline";
-var CHAIN_BUDGET_MESSAGE = "the chain's total budget ran out before this model was given a fair turn";
-
-// src/agent/structured.ts
-function valueAt(args, path) {
-  let cur = args;
-  for (const key of path) {
-    if (typeof cur !== "object" || cur === null) return void 0;
-    cur = cur[key];
-  }
-  return cur;
-}
-function whatWasWrong(issues, args) {
-  return issues.map((i) => {
-    const where = i.path.length ? i.path.join(".") : void 0;
-    const got = valueAt(args, i.path);
-    const shown = got === void 0 ? "nothing" : JSON.stringify(got);
-    const head = where ? `${where}: ${i.message}` : i.message;
-    if (got === void 0 && /received\s+(undefined|null|nothing)/i.test(i.message)) {
-      const parent = i.path.length > 1 ? valueAt(args, i.path.slice(0, -1)) : args;
-      const sent = parent && typeof parent === "object" ? Object.keys(parent) : [];
-      return sent.length ? `${head} \u2014 you sent only ${sent.map((k) => `\`${k}\``).join(", ")}` : head;
-    }
-    return `${head} \u2014 got ${shown.length > 120 ? `${shown.slice(0, 120)}\u2026` : shown}`;
-  }).join("; ");
-}
-function buildSubmitTool(schema) {
-  let box;
-  const tool = {
-    name: "submit",
-    description: "When you are done, submit your result in structured form with this tool.",
-    permissionLevel: "safe",
-    parameters: schema,
-    run: async (rawArgs) => {
-      const parsed = schema.safeParse(rawArgs);
-      if (!parsed.success) {
-        return { content: `submit: invalid output: ${whatWasWrong(parsed.error.issues, rawArgs)}`, isError: true };
-      }
-      box = { value: parsed.data };
-      return { content: "received", isError: false };
-    }
-  };
-  return { tool, result: () => box };
-}
-function extractStructured(text, schema) {
-  const trimmed = text.trim();
-  if (!trimmed) return void 0;
-  const candidates = [trimmed];
-  const block = trimmed.match(/\{[\s\S]*\}/);
-  if (block) candidates.push(block[0]);
-  for (const c of candidates) {
-    try {
-      const parsed = schema.safeParse(JSON.parse(c));
-      if (parsed.success) return parsed.data;
-    } catch {
-    }
-  }
-  return void 0;
-}
-var TURN_LIMIT_RE = /maximum turn count exceeded/i;
-async function runStructuredRole(opts, schema, maxAttempts = 2) {
-  const handle = buildSubmitTool(schema);
-  const registry = new ToolRegistry();
-  for (const t of opts.tools.list()) registry.register(t);
-  registry.register(handle.tool);
-  const chain = [opts.model, ...opts.fallbacks ?? []];
-  const total = opts.totalMs ? AbortSignal.timeout(opts.totalMs) : void 0;
-  const outOfTime = () => total?.aborted === true;
-  const signalFor = () => {
-    const parts = [opts.signal];
-    if (total) parts.push(total);
-    if (opts.perAttemptMs) parts.push(AbortSignal.timeout(opts.perAttemptMs));
-    return parts.length === 1 ? opts.signal : AbortSignal.any(parts);
-  };
-  let lastError;
-  for (let ci = 0; ci < chain.length; ci++) {
-    const model = chain[ci];
-    if (ci > 0) opts.onFallback?.(chain[ci - 1], model, "structured: previous model returned no valid result");
-    const messages = [...opts.messages];
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      if (opts.signal.aborted) throw new Error("cancelled");
-      if (outOfTime()) break;
-      let lastText = "";
-      let errored;
-      for await (const ev of runRoleAgent({ ...opts, model, fallbacks: [], messages, tools: registry, signal: signalFor() })) {
-        if (ev.type === "error") {
-          errored = ev.message;
-          break;
-        }
-        if (ev.type === "abort") {
-          if (opts.signal.aborted) throw new Error("cancelled");
-          errored = total?.aborted ? CHAIN_BUDGET_MESSAGE : DEADLINE_MESSAGE;
-          break;
-        }
-        if (ev.type === "message.done") lastText = ev.message.content ?? lastText;
-        if (handle.result() !== void 0) break;
-      }
-      const r = handle.result();
-      if (r !== void 0) return r.value;
-      const salvaged = extractStructured(lastText, schema);
-      if (salvaged !== void 0) return salvaged;
-      if (errored !== void 0) {
-        if (TURN_LIMIT_RE.test(errored) && attempt < maxAttempts - 1) {
-          messages.push({ role: "assistant", content: lastText });
-          messages.push({ role: "user", content: "You have used your entire tool-call budget. Call `submit` NOW with the findings you already have. Do not read, grep or inspect anything else." });
-          continue;
-        }
-        lastError = errored;
-        break;
-      }
-      messages.push({ role: "assistant", content: lastText });
-      messages.push({
-        role: "user",
-        content: "You did not call the `submit` tool. Call `submit` now with your result as structured arguments \u2014 do not answer in prose."
-      });
-    }
-    if (opts.signal.aborted) throw new Error("cancelled");
-    if (outOfTime()) throw new Error("the model chain did not produce a result within its total budget");
-    opts.onStructuralFailure?.(model, "answered in prose instead of calling submit");
-  }
-  throw new Error(lastError ?? "structured role: submit was not called (whole model chain tried)");
-}
-
 export {
   fmtTokens,
   fmtDuration,
@@ -1381,7 +1175,6 @@ export {
   setTelemetry,
   telemetry,
   redactSecrets,
-  runToCompletion,
-  ToolRegistry,
-  runStructuredRole
+  runRoleAgent,
+  runToCompletion
 };

package/dist/{chunk-KKWZBZYK.js → chunk-JR2JLRE3.js}

@@ -3,6 +3,9 @@ import {
   objectField,
   patchConfig
 } from "./chunk-H2FDGPVW.js";
+import {
+  CLI_KINDS
+} from "./chunk-G45RWL7S.js";
 
 // src/config/config.ts
 import { z } from "zod";
@@ -61,14 +64,33 @@ var fileSchema = z.object({
   council: z.object({ members: z.array(reviewerSchema) }).optional(),
   specKit: z.object({ version: z.string() }).optional(),
   modelSources: z.array(z.string()).optional(),
-  // Logged-in profile directories, in spill order. A path each, never a credential.
+  /**
+   * Logged-in profile directories, in spill order. A path each, never a credential.
+   *
+   * Two things here were wrong in a way that could not be seen from this file, and both were found by
+   * connecting a real account.
+   *
+   * The kinds were spelled out — `["claude", "codex"]` — and every entry of a kind added since was
+   * rejected. `CLI_KINDS` is where they are declared, so this reads them rather than repeating them, and a
+   * fifth subscription cannot be half-added again.
+   *
+   * `configDir` was REQUIRED, and the signed-in default is precisely the entry that has none: `withAmbient`
+   * records it without a directory, deliberately, because Claude Code keeps that session in the Keychain
+   * and naming a directory switches it to file credentials. So the one entry written to stop a second
+   * account quietly retiring the first was itself unloadable.
+   *
+   * `.catch([])` bounds what a bad row can cost. The loader reads `parsed.success ? parsed.data : {}`, so
+   * a single rejected entry did not merely drop that account — it discarded the WHOLE global config.
+   * Measured on a live one: the file held 64 role chains and an API key, and with one z.ai entry present
+   * `loadConfig` returned zero roles and no key, silently, for every session since it was connected.
+   */
   accounts: z.array(z.object({
-    kind: z.enum(["claude", "codex"]),
+    kind: z.enum(CLI_KINDS),
     name: z.string(),
-    configDir: z.string(),
+    configDir: z.string().optional(),
     email: z.string().optional(),
     plan: z.string().optional()
-  })).optional(),
+  })).catch([]).optional(),
   traceDir: z.string().optional(),
   // where /graph trace writes; empty = .horsecode/traces
   mainBranch: z.string().optional(),