@hizliemre/horse-code 0.1.0

package/dist/chunk-FGVJFMK5.js

@@ -0,0 +1,123 @@
+import {
+  writeAtomicSync
+} from "./chunk-B67BK5GQ.js";
+
+// src/engine/checkpoint.ts
+import { existsSync, readFileSync, rmSync, statSync } from "fs";
+import { join } from "path";
+function checkpointPath(worktreeRoot) {
+  return join(worktreeRoot, "checkpoint.json");
+}
+function checkpointKey(prompt) {
+  return prompt.trim().replace(/\s+/g, " ").toLowerCase();
+}
+var CONTINUE_FILLER = /* @__PURE__ */ new Set([
+  // Turkish: devam + its inflections, "where we left off", and the usual padding.
+  "devam",
+  "et",
+  "et.",
+  "edelim",
+  "edin",
+  "ediyoruz",
+  "edece\u011Fiz",
+  "edecegiz",
+  "edeceksin",
+  "ettik",
+  "edeyim",
+  "kald\u0131\u011F\u0131m\u0131z",
+  "kaldigimiz",
+  "kald\u0131\u011F\u0131n",
+  "kaldigin",
+  "kald\u0131\u011F\u0131",
+  "kaldigi",
+  "kald\u0131k",
+  "kaldik",
+  "yerden",
+  "hadi",
+  "l\xFCtfen",
+  "lutfen",
+  "tamam",
+  "bakal\u0131m",
+  "bakalim",
+  "art\u0131k",
+  "artik",
+  "mi",
+  "m\u0131",
+  "mu",
+  "m\xFC",
+  // English.
+  "continue",
+  "resume",
+  "carry",
+  "on",
+  "keep",
+  "going",
+  "pick",
+  "up",
+  "where",
+  "from",
+  "we",
+  "left",
+  "off",
+  "let's",
+  "lets",
+  "us",
+  "please",
+  "ok",
+  "okay",
+  "just",
+  "the",
+  "it",
+  "you",
+  "i",
+  "and",
+  "then",
+  "now"
+]);
+var CONTINUE_VERB = /(^|\s)(devam|kald[ıi]\w*|continue|resume|carry on|keep going|pick up (where|from))(\s|$|[.,!?])/i;
+function isContinuePrompt(text) {
+  const t = text.trim();
+  if (!t || t.length > 200) return false;
+  if (!CONTINUE_VERB.test(t)) return false;
+  const rest = t.toLowerCase().split(/[\s,.!?;:]+/).filter(Boolean).filter((w) => !CONTINUE_FILLER.has(w));
+  return rest.length <= 1;
+}
+function checkpointMtime(worktreeRoot) {
+  try {
+    return statSync(checkpointPath(worktreeRoot)).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function readCheckpoint(worktreeRoot) {
+  const p = checkpointPath(worktreeRoot);
+  if (!existsSync(p)) return null;
+  try {
+    const cp = JSON.parse(readFileSync(p, "utf8"));
+    if (!Array.isArray(cp.done)) return null;
+    return cp;
+  } catch {
+    return null;
+  }
+}
+function writeCheckpoint(worktreeRoot, cp) {
+  try {
+    writeAtomicSync(checkpointPath(worktreeRoot), JSON.stringify(cp, null, 2));
+  } catch {
+  }
+}
+function clearCheckpoint(worktreeRoot) {
+  try {
+    rmSync(checkpointPath(worktreeRoot), { force: true });
+  } catch {
+  }
+}
+
+export {
+  checkpointKey,
+  isContinuePrompt,
+  checkpointMtime,
+  readCheckpoint,
+  writeCheckpoint,
+  clearCheckpoint
+};

package/dist/chunk-H2FDGPVW.js

@@ -0,0 +1,42 @@
+// src/config/patch.ts
+import { mkdir, readFile, writeFile, rename } from "fs/promises";
+import { dirname, join } from "path";
+async function patchConfig(home, mutate) {
+  const path = join(home, ".horsecode", "config.json");
+  let current = {};
+  try {
+    const raw = await readFile(path, "utf8");
+    if (raw.trim()) {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+      current = parsed;
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") return false;
+  }
+  const next = mutate(current);
+  if (!next) return false;
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    await rename(tmp, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function objectField(current, key) {
+  const v = current[key];
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? { ...v } : {};
+}
+function arrayField(current, key) {
+  return Array.isArray(current[key]) ? [...current[key]] : [];
+}
+
+export {
+  patchConfig,
+  objectField,
+  arrayField
+};

package/dist/chunk-HBSC2HT2.js

@@ -0,0 +1,85 @@
+import {
+  ToolRegistry,
+  runStructuredRole
+} from "./chunk-YILDXPSI.js";
+
+// src/engine/user-language.ts
+import { z } from "zod";
+var Translated = z.object({
+  text: z.string().describe("The same text, in the requested language. No commentary, no quotes.")
+});
+var PROMPT = "You translate one short piece of interface text for a terminal tool. Return the SAME text in the language you are given: same meaning, same tone, same length, nothing added and nothing explained. Leave branch names, file paths, commands and other identifiers exactly as they are \u2014 they are not words, they are names. Return the result via submit.";
+function isEnglish(language) {
+  return !language?.trim() || /^english$/i.test(language.trim());
+}
+async function inUserLanguage(deps, text, language) {
+  if (isEnglish(language)) return text;
+  try {
+    const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("refiner");
+    const said = await runStructuredRole({
+      provider: deps.provider,
+      role: agentRole,
+      model,
+      fallbacks,
+      onExhausted,
+      onFallback,
+      // The project's own rules shape what the user reads — the same reason normalizeQuestion carries them.
+      systemPrompt: PROMPT + deps.roleRegistry.ruleSuffix(),
+      tools: new ToolRegistry(),
+      messages: [{ role: "user", content: `Language: ${language}
+
+${text}` }],
+      permission: deps.permission,
+      approve: deps.approve,
+      cwd: ".",
+      signal: deps.signal
+    }, Translated);
+    return said.text.trim() || text;
+  } catch {
+    return text;
+  }
+}
+var Asked = z.object({
+  question: z.string().describe("The question, in the requested language."),
+  options: z.array(z.object({
+    label: z.string().describe("The choice's label, in the requested language. Keep it short \u2014 it is a name."),
+    description: z.string().optional().describe("Its one-line explanation, in the requested language.")
+  })).describe("Same choices, same order. Never add, drop or reorder them.")
+});
+async function askInUserLanguage(deps, askUser, language, question, options) {
+  if (isEnglish(language) || !options?.length) {
+    const q = isEnglish(language) ? question : await inUserLanguage(deps, question, language);
+    return askUser(q, options ? { options } : void 0);
+  }
+  try {
+    const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("refiner");
+    const said = await runStructuredRole({
+      provider: deps.provider,
+      role: agentRole,
+      model,
+      fallbacks,
+      onExhausted,
+      onFallback,
+      systemPrompt: PROMPT + deps.roleRegistry.ruleSuffix(),
+      tools: new ToolRegistry(),
+      messages: [{ role: "user", content: `Language: ${language}
+
+${JSON.stringify({ question, options })}` }],
+      permission: deps.permission,
+      approve: deps.approve,
+      cwd: ".",
+      signal: deps.signal
+    }, Asked);
+    if (said.options.length !== options.length) return askUser(question, { options });
+    const answer = (await askUser(said.question, { options: said.options })).trim();
+    const at = said.options.findIndex((o) => o.label.trim() === answer);
+    return at >= 0 ? options[at].label : answer;
+  } catch {
+    return askUser(question, { options });
+  }
+}
+
+export {
+  inUserLanguage,
+  askInUserLanguage
+};

package/dist/chunk-IW2KBAVZ.js

@@ -0,0 +1,21 @@
+// src/worktree/git.ts
+import { spawn } from "child_process";
+var defaultGitRunner = (args, cwd) => new Promise((resolve) => {
+  let stdout = "";
+  let stderr = "";
+  let child;
+  try {
+    child = spawn("git", args, { cwd });
+  } catch (e) {
+    resolve({ stdout, stderr: e instanceof Error ? e.message : String(e), code: -1 });
+    return;
+  }
+  child.stdout?.on("data", (d) => stdout += d.toString());
+  child.stderr?.on("data", (d) => stderr += d.toString());
+  child.on("error", (e) => resolve({ stdout, stderr: stderr + e.message, code: -1 }));
+  child.on("close", (code) => resolve({ stdout, stderr, code: code ?? -1 }));
+});
+
+export {
+  defaultGitRunner
+};

package/dist/chunk-JWAEW7AJ.js

@@ -0,0 +1,121 @@
+import {
+  Board,
+  refreshAfterChange,
+  runTaskCycle
+} from "./chunk-3XVZXTB6.js";
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+
+// src/engine/fix.ts
+function cardFromFinding(f, id) {
+  return {
+    id,
+    title: f.title,
+    /**
+     * Its own acceptance criteria, with a floor.
+     *
+     * The gate can only check what it was given, so a finding reported without criteria would pass by having
+     * been attempted. The detail is what the person actually saw, which is the one statement that is always
+     * true of a real fix: that is no longer what happens.
+     */
+    acceptance: f.acceptance.length ? f.acceptance : [`No longer happens: ${f.detail}`],
+    files: f.files
+  };
+}
+var FIX_ATTEMPTS = 2;
+function whyItDidNotTake(notes) {
+  return `An earlier attempt at this in the same session did not settle it. The acceptance check said: ${notes.join("; ") || "it was still not true afterwards"}. That is a description of what is still wrong \u2014 find why the change did not take rather than making the same one again.`;
+}
+async function runFix(deps, workdir, f, id = "fix-1") {
+  let last = { title: f.title, fixed: false, notes: [] };
+  for (let attempt = 1; attempt <= FIX_ATTEMPTS; attempt++) {
+    const cardId = attempt === 1 ? id : `${id}-retry${attempt - 1}`;
+    try {
+      const board = new Board();
+      board.addCard(cardFromFinding(f, cardId));
+      if (attempt > 1) board.addReviewNote(cardId, whyItDidNotTake(last.notes));
+      const verdict = await runTaskCycle(deps, board, cardId, workdir);
+      last = {
+        title: f.title,
+        fixed: verdict.verdict === "pass",
+        notes: verdict.verdict === "pass" ? [] : verdict.noProgress ? ["nothing was written"] : verdict.notes
+      };
+    } catch (e) {
+      last = { title: f.title, fixed: false, notes: [e instanceof Error ? e.message : String(e)] };
+    }
+    if (last.fixed) return last;
+  }
+  return last;
+}
+async function dirtyPaths(git, cwd) {
+  const r = await git(["status", "--porcelain"], cwd);
+  if (r.code !== 0) return /* @__PURE__ */ new Set();
+  return new Set(r.stdout.split("\n").map((l) => l.slice(3).trim()).filter(Boolean));
+}
+async function commitOnly(git, cwd, before, message) {
+  const after = await dirtyPaths(git, cwd);
+  const mine = [...after].filter((p) => !before.has(p));
+  if (!mine.length) return [];
+  const add = await git(["add", "--", ...mine], cwd);
+  if (add.code !== 0) return [];
+  const staged = await git(["diff", "--cached", "--quiet", "--", ...mine], cwd);
+  if (staged.code === 0) return [];
+  const r = await git(["commit", "-m", message, "--", ...mine], cwd);
+  return r.code === 0 ? mine : [];
+}
+async function commitFix(workdir, f, before) {
+  return commitOnly(defaultGitRunner, workdir, before, `fix: ${f.title}`);
+}
+function describeFix(r) {
+  return r.fixed ? `\u{1F527} Fixed: **${r.title}** \u2014 implemented, reviewed, and checked against what the finding asked for.` : `\u26A0\uFE0F Not fixed: **${r.title}**${r.notes.length ? ` \u2014 ${r.notes.slice(0, 3).join("; ")}` : ""}. It stays in the report as an open finding.`;
+}
+async function runSmallChange(deps, workdir, title, prompt, spec) {
+  const before = await dirtyPaths(defaultGitRunner, workdir);
+  let res;
+  try {
+    const board = new Board();
+    const acceptance = spec.acceptance.length ? spec.acceptance : [`The request is satisfied: ${prompt}`];
+    board.addCard({ id: "small-1", title: prompt, acceptance, files: spec.files });
+    const verdict = await runTaskCycle(deps, board, "small-1", workdir);
+    res = {
+      title,
+      fixed: verdict.verdict === "pass",
+      notes: verdict.verdict === "pass" ? [] : verdict.noProgress ? ["nothing was written"] : verdict.notes
+    };
+  } catch (e) {
+    res = { title, fixed: false, notes: [e instanceof Error ? e.message : String(e)] };
+  }
+  const files = res.fixed ? await commitOnly(defaultGitRunner, workdir, before, prompt) : [];
+  await refreshAfterChange({
+    cwd: workdir,
+    files,
+    provider: deps.provider,
+    models: deps.roleRegistry.chainFor("tracer", 0),
+    signal: deps.signal,
+    ...deps.note ? { note: deps.note } : {}
+  });
+  return { ...res, committed: files.length > 0 };
+}
+function describeSmallChange(r, reason, branch) {
+  if (!r.fixed) {
+    return `\u26A0\uFE0F Not done: ${r.notes.join("; ") || "the change did not pass review"}.
+
+Nothing was committed. Ask again with more detail, or say so and I will treat it as a full piece of work.`;
+  }
+  return `\u2705 Done \u2014 implemented, reviewed, and checked against what was asked.
+
+_Handled as a small change (${reason}): no branch, no spec, no plan._ ` + (r.committed ? `Committed on \`${branch}\`.` : `Nothing was left to commit \u2014 the working tree already had it.`);
+}
+
+export {
+  cardFromFinding,
+  FIX_ATTEMPTS,
+  runFix,
+  dirtyPaths,
+  commitOnly,
+  commitFix,
+  describeFix,
+  runSmallChange,
+  describeSmallChange
+};

package/dist/chunk-NNTIACT4.js

@@ -0,0 +1,163 @@
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+import {
+  briefForPrompt,
+  briefPrompt,
+  briefStatus,
+  gatherBriefInput,
+  saveBrief
+} from "./chunk-DTWKSZXY.js";
+import {
+  ensureGitignore,
+  loadTraceIndex,
+  planTraces,
+  pruneTraces,
+  saveTrace,
+  saveTraceIndex,
+  traceCoverage,
+  tracePrompt,
+  traceRootRel,
+  traceable
+} from "./chunk-FFYBY2NA.js";
+import {
+  loadGraph
+} from "./chunk-PGOYDOI4.js";
+
+// src/engine/trace-run.ts
+async function traceableFiles(cwd, opts) {
+  const r = await defaultGitRunner(["ls-files", "--cached", "--others", "--exclude-standard"], cwd);
+  return traceable(r.stdout.split("\n").filter(Boolean), opts);
+}
+async function coverageFor(cwd) {
+  return traceCoverage(cwd, await traceableFiles(cwd), await loadTraceIndex(cwd));
+}
+var TRACE_CONCURRENCY = 6;
+var INDEX_CHECKPOINT = 25;
+function describePlan(plan, model) {
+  if (!plan.jobs.length) {
+    return plan.upToDate ? `All ${plan.upToDate} traces are current \u2014 nothing to write, nothing to spend.` : "No files to trace.";
+  }
+  const kIn = Math.round(plan.estimatedInputTokens / 1e3);
+  const kOut = Math.round(plan.estimatedOutputTokens / 1e3);
+  const skipped = plan.skipped.length ? `
+
+${plan.skipped.length} file(s) skipped as too large to trace economically (e.g. ${plan.skipped.slice(0, 3).map((s) => `\`${s.file}\``).join(", ")}${plan.skipped.length > 3 ? ", \u2026" : ""}).` : "";
+  const cached = plan.upToDate ? `
+${plan.upToDate} file(s) already have a current trace and will be left alone.` : "";
+  return `**Tracing ${plan.jobs.length} file(s)** with \`${model}\`.
+
+This is the part of understanding your project that costs tokens \u2014 the graph was free, this is not. Each file is read once and described in ~150 words.
+
+Rough cost: **~${kIn}k input + ~${kOut}k output tokens**.${cached}${skipped}`;
+}
+async function traceOne(provider, model, job, signal, brief) {
+  const req = {
+    model,
+    messages: [
+      { role: "system", content: "You write terse, factual reference notes about source files. You never speculate." },
+      { role: "user", content: tracePrompt(job, brief) }
+    ],
+    tools: []
+  };
+  let out = "";
+  for await (const ev of provider.chat(req, signal)) {
+    if (ev.type === "text-delta") out += ev.text;
+    else if (ev.type === "error") throw new Error(ev.message);
+  }
+  const body = out.replace(/<\/?think>/gi, "").trim();
+  if (!body) throw new Error("empty response");
+  return body;
+}
+async function runTraces(opts) {
+  const { cwd, plan } = opts;
+  const signal = opts.signal ?? new AbortController().signal;
+  const index = await loadTraceIndex(cwd);
+  const brief = briefForPrompt(cwd);
+  const failed = [];
+  let written = 0;
+  let done = 0;
+  const queue = [...plan.jobs];
+  const worker = async () => {
+    for (; ; ) {
+      const job = queue.shift();
+      if (!job || signal.aborted) return;
+      let wroteTo;
+      let words;
+      let error;
+      try {
+        const body = await traceOne(opts.provider, opts.model, job, signal, brief);
+        const rec = await saveTrace(cwd, job, body, opts.model);
+        index.traces[job.file] = rec;
+        wroteTo = `${traceRootRel()}/${job.file}.md`;
+        words = body.split(/\s+/).filter(Boolean).length;
+        written++;
+        if (written % INDEX_CHECKPOINT === 0) await saveTraceIndex(cwd, index);
+      } catch (e) {
+        if (signal.aborted) return;
+        error = e instanceof Error ? e.message : String(e);
+        failed.push({ file: job.file, error });
+      }
+      opts.onProgress?.({
+        done: ++done,
+        total: plan.jobs.length,
+        file: job.file,
+        ...wroteTo !== void 0 && { wroteTo },
+        ...words !== void 0 && { words },
+        ...error !== void 0 && { error }
+      });
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(TRACE_CONCURRENCY, queue.length) }, worker));
+  const pruned = opts.liveFiles ? await pruneTraces(cwd, opts.liveFiles, index) : [];
+  await saveTraceIndex(cwd, index);
+  const wroteGitignore = written > 0 && await ensureGitignore(cwd);
+  return { written, failed, pruned, upToDate: plan.upToDate, cancelled: signal.aborted, wroteGitignore };
+}
+async function planFor(cwd, files) {
+  return planTraces(cwd, files, await loadGraph(cwd), await loadTraceIndex(cwd));
+}
+async function buildBrief(opts) {
+  if (!opts.force) {
+    const st = await briefStatus(opts.cwd, opts.files);
+    if (st.built && !st.stale) {
+      return { ok: true, skipped: true, message: `Project brief is current (${st.sources.length} document(s)) \u2014 not rewritten.` };
+    }
+  }
+  const input = await gatherBriefInput(opts.cwd, opts.files);
+  if (!input) {
+    return { ok: false, message: "No documentation found (README, docs/, specs/) \u2014 traces will describe the code without product context." };
+  }
+  const signal = opts.signal ?? new AbortController().signal;
+  const req = {
+    model: opts.model,
+    messages: [
+      { role: "system", content: "You write factual project briefings from documentation. You never invent facts the documents do not state." },
+      { role: "user", content: briefPrompt(input) }
+    ],
+    tools: []
+  };
+  let out = "";
+  try {
+    for await (const ev of opts.provider.chat(req, signal)) {
+      if (ev.type === "text-delta") out += ev.text;
+      else if (ev.type === "error") throw new Error(ev.message);
+    }
+  } catch (e) {
+    return { ok: false, message: `Project brief failed (${e instanceof Error ? e.message : String(e)}) \u2014 tracing can still run without it.` };
+  }
+  const body = out.replace(/<\/?think>/gi, "").trim();
+  if (!body) return { ok: false, message: "The brief came back empty \u2014 tracing can still run without it." };
+  await saveBrief(opts.cwd, body, { hash: input.hash, sources: input.sources.map((s) => s.file), writtenAt: Date.now(), model: opts.model });
+  return { ok: true, message: `**Project brief** written from ${input.sources.length} document(s): ${input.sources.slice(0, 6).map((s) => `\`${s.file}\``).join(", ")}` };
+}
+
+export {
+  traceableFiles,
+  coverageFor,
+  TRACE_CONCURRENCY,
+  describePlan,
+  runTraces,
+  planFor,
+  buildBrief
+};

package/dist/chunk-O74BDQKS.js

@@ -0,0 +1,28 @@
+// src/providers/models.ts
+var KNOWN_FREE_PROVIDER = /^(ddgw|duckduckgo|veoaifree)/i;
+function isFreeModel(id, name) {
+  const n = name ?? "";
+  if (/🆓/.test(n) || /\bfree\b/i.test(n)) return true;
+  if (/-free\b/i.test(id)) return true;
+  const provider = id.split("/")[0];
+  return /free/i.test(provider) || KNOWN_FREE_PROVIDER.test(provider);
+}
+async function listOmniRouteModels(opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const headers = {};
+  if (opts.apiKey) headers.Authorization = `Bearer ${opts.apiKey}`;
+  const base = opts.baseUrl.replace(/\/$/, "");
+  const res = await fetchFn(`${base}/api/v1/models`, { headers });
+  if (!res.ok) throw new Error(`omniroute models ${res.status}`);
+  const body = await res.json();
+  const allow = opts.sources && opts.sources.length ? new Set(opts.sources) : void 0;
+  const kept = (body.data ?? []).filter((m) => typeof m.id === "string").filter((m) => !isFreeModel(m.id, typeof m.name === "string" ? m.name : void 0)).filter((m) => !allow || typeof m.owned_by === "string" && allow.has(m.owned_by));
+  const keptIds = new Set(kept.map((m) => m.id));
+  const ids = kept.filter((m) => !(typeof m.parent === "string" && keptIds.has(m.parent))).map((m) => m.id);
+  return [...new Set(ids)].sort();
+}
+
+export {
+  isFreeModel,
+  listOmniRouteModels
+};