@hizliemre/horse-code 0.1.0

package/dist/chunk-5UWA2UBM.js

@@ -0,0 +1,69 @@
+// src/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+// src/version.ts
+var VERSION = "0.0.0";
+
+// src/mcp/client.ts
+function renderContent(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : JSON.stringify(content);
+  return content.map((c) => {
+    const block = c;
+    if (block.type === "text" && typeof block.text === "string") return block.text;
+    return `[${block.type ?? "content"}]`;
+  }).join("\n");
+}
+function clientFor() {
+  return new Client({ name: "horse-code", version: VERSION }, { capabilities: {} });
+}
+async function connectRemote(url, headers) {
+  const target = new URL(url);
+  const init = headers ? { requestInit: { headers } } : void 0;
+  try {
+    const client = clientFor();
+    await client.connect(new StreamableHTTPClientTransport(target, init));
+    return client;
+  } catch {
+    const client = clientFor();
+    await client.connect(new SSEClientTransport(target, init));
+    return client;
+  }
+}
+async function connectMcpServer(name, spec) {
+  const client = "command" in spec ? await (async () => {
+    const c = clientFor();
+    await c.connect(new StdioClientTransport({
+      command: spec.command[0],
+      args: spec.command.slice(1),
+      env: { ...process.env, ...spec.env ?? {} }
+    }));
+    return c;
+  })() : await connectRemote(spec.url, spec.headers);
+  const listed = await client.listTools();
+  const declaredReadOnly = spec.readOnly === true;
+  const tools = listed.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
+    readOnly: declaredReadOnly || t.annotations?.readOnlyHint === true
+  }));
+  return {
+    name,
+    tools,
+    async callTool(tool, args) {
+      const res = await client.callTool({ name: tool, arguments: args });
+      return { content: renderContent(res.content), isError: res.isError === true };
+    },
+    async close() {
+      await client.close().catch(() => {
+      });
+    }
+  };
+}
+
+export {
+  connectMcpServer
+};

package/dist/chunk-7TBYMFMG.js

@@ -0,0 +1,147 @@
+import {
+  contextTools,
+  globTool,
+  grepTool,
+  memoryHints,
+  readFileTool,
+  reinforceUsed
+} from "./chunk-TOPZL5SU.js";
+import {
+  ToolRegistry,
+  runStructuredRole
+} from "./chunk-YILDXPSI.js";
+
+// src/engine/triage.ts
+import { z } from "zod";
+var SIZE_MAX_TURNS = 12;
+var SIZE_TOTAL_MS = 18e4;
+var SIZE_ATTEMPT_MS = 9e4;
+var TriageSchema = z.object({
+  depth: z.enum(["task", "brainstorm", "full"]).describe(
+    "How much process this finding deserves, and therefore what it costs. `task`: the fix is obvious once seen \u2014 go straight to it. `brainstorm`: something has to be DECIDED before anyone writes code. `full`: the finding reaches beyond itself and needs a specification. Prefer the smallest depth the evidence supports: buying a spec for a label is waste."
+  ),
+  reason: z.string().describe("One sentence: what about this finding puts it at that depth.")
+});
+var PROMPT = "You size a defect found during manual testing, to decide how much process it deserves. You are not fixing it and you are not designing the fix.\n\nRead the code before you answer \u2014 the same words describe a one-line label fix and a rework of how a screen gets its data, and only the code says which this is.\n\n`task`: the change is known and contained. A wrong label, a missing field on a screen that already has the data, a formatting bug, a validation that is checking the wrong thing. Most findings are this.\n\n`brainstorm`: the fix is not obvious, or there is more than one reasonable way and they differ in a way the user would care about. Decide WITH them rather than guessing.\n\n`full`: this is not a fix. It is a piece of work that testing happened to discover \u2014 a capability that was never built, a design that does not hold, something that touches several parts of the system.\n\nPrefer the smallest depth the evidence supports. Buying a spec for a label is waste; but a `task` that turns out to be a redesign is worse, because it is written and reviewed as if it were understood.";
+async function triageFinding(deps, workdir, f) {
+  const tools = new ToolRegistry();
+  tools.register(readFileTool);
+  tools.register(grepTool);
+  tools.register(globTool);
+  for (const t of contextTools(deps)) tools.register(t);
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("analyst");
+  const message = `A defect was found while manually testing existing work.
+
+Title: ${f.title}
+
+What was seen:
+${f.detail}
+` + (f.files.length ? `
+Files it appears to involve:
+${f.files.map((x) => `- ${x}`).join("\n")}
+` : "") + (f.acceptance.length ? `
+What must be true for it to be settled:
+${f.acceptance.map((x) => `- ${x}`).join("\n")}
+` : "") + `
+Size it.`;
+  const hints = memoryHints(deps, `${f.title} ${f.detail} ${f.files.join(" ")}`, { role: "analyst" });
+  const opts = {
+    provider: deps.provider,
+    role: agentRole,
+    model,
+    fallbacks,
+    onExhausted,
+    onFallback,
+    // A role that DECIDES has to know the user's standing rules — see test/agent/rules-reach-roles.test.ts.
+    systemPrompt: PROMPT + deps.roleRegistry.ruleSuffix(),
+    tools,
+    maxTurns: SIZE_MAX_TURNS,
+    perAttemptMs: SIZE_ATTEMPT_MS,
+    totalMs: SIZE_TOTAL_MS,
+    messages: hints.message ? [{ role: "user", content: hints.message }, { role: "user", content: message }] : [{ role: "user", content: message }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal
+  };
+  try {
+    const t = await runStructuredRole(opts, TriageSchema);
+    reinforceUsed(deps, hints.ids, t.reason, "analyst");
+    return t;
+  } catch {
+    return { depth: "task", reason: "the triage could not run; treated as a contained change" };
+  }
+}
+function describeEscalation(f, t) {
+  const what = t.depth === "brainstorm" ? "decide the approach with you first, then implement it" : "write a spec and a plan for it, then break it into tasks";
+  return `**${f.title}**
+
+This is bigger than a single fix \u2014 ${t.reason}
+
+I would ${what}.`;
+}
+var RequestSizeSchema = z.object({
+  verdict: z.enum(["small", "large", "unsure"]).describe(
+    "How big the change is, which decides whether the whole spec/plan pipeline runs. `small`: contained to a file or two with nothing to DECIDE once you have read the code. `large`: it needs designing, or it spreads across the system. `unsure`: the code did not tell you \u2014 say so rather than guessing, because a wrong `small` skips every gate and a wrong `large` buys a specification for a typo."
+  ),
+  reason: z.string().describe("One sentence: what makes it that size, or what you are unsure about."),
+  acceptance: z.array(z.string()).default([]).describe("If small or unsure: what must be true when it is done. One checkable statement each."),
+  files: z.array(z.string()).default([]).describe("If small or unsure: the repo-relative files it touches.")
+});
+var SIZE_PROMPT = 'You size a change request, to decide how much process it deserves. You are not doing the work and you are not designing it.\n\nRead the code first. The same sentence describes a one-line style change and a rework of a component, and only the code says which this is. You are sizing, not implementing: stop as soon as you can tell which side of the line it falls on.\n\n`small`: the change is contained to a file or two and there is nothing to DECIDE \u2014 what to do follows from the request once you have seen the code. Centre an icon. Change a colour. Fix a typo. Rename a label. Correct a format string. Add a missing field to a screen that already has the data. Clamp a line count. Most requests a person types in one sentence are this.\n\nIt is still small when it needs a test, a small refactor to make room, or touching a second file that the first one obviously depends on. Small means CONTAINED and DECIDED, not trivial.\n\n`large`: a new capability, a design that has to be settled with the user, or a change reaching across several parts of the system. Those get the full pipeline, which exists to work out WHAT to build.\n\n`unsure`: you cannot tell from the code which of those it is. Say so. The developer is sitting there and one question costs them a sentence.\n\nDo NOT resolve doubt by choosing `large`. A mistake on the small path is cheap \u2014 the change is written, reviewed by a code reviewer, and checked against the acceptance criteria you give below, all in front of someone watching. A mistake the other way costs an hour and a half of spec, plan, board and review panels. Measured: one request called `large` produced 507 model calls over 94 minutes for a fix the developer described as a simple UI change.\n\nFor `small` or `unsure`, give the acceptance criteria and the files. Those are what the change will be judged against, so they must be checkable by looking at the result \u2014 not "the icon looks better".';
+function describeSizeDoubt(prompt, reason) {
+  return `**${prompt}**
+
+I cannot tell how big this is from the code \u2014 ${reason}
+
+As a small change it goes straight to an implementer, is reviewed, and is checked against acceptance criteria: no branch, no spec, no plan. As a full piece of work it gets a spec, a plan and a task board first, which is right when the approach has to be worked out and expensive when it does not.`;
+}
+async function sizeRequest(deps, workdir, prompt) {
+  const tools = new ToolRegistry();
+  tools.register(readFileTool);
+  tools.register(grepTool);
+  tools.register(globTool);
+  for (const t of contextTools(deps)) tools.register(t);
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("analyst");
+  const opts = {
+    provider: deps.provider,
+    role: agentRole,
+    model,
+    fallbacks,
+    onExhausted,
+    onFallback,
+    systemPrompt: SIZE_PROMPT + deps.roleRegistry.ruleSuffix(),
+    tools,
+    maxTurns: SIZE_MAX_TURNS,
+    perAttemptMs: SIZE_ATTEMPT_MS,
+    totalMs: SIZE_TOTAL_MS,
+    messages: [{ role: "user", content: `Request: "${prompt}"
+
+Size it.` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal
+  };
+  try {
+    const r = await runStructuredRole(opts, RequestSizeSchema);
+    if (r.verdict === "small" && !r.acceptance.length) {
+      return { ...r, verdict: "unsure", reason: `${r.reason} \u2014 but no checkable criteria came out of it` };
+    }
+    return r;
+  } catch {
+    return { verdict: "unsure", reason: "I could not work out its size from the code in the time allowed", acceptance: [], files: [] };
+  }
+}
+
+export {
+  SIZE_MAX_TURNS,
+  SIZE_TOTAL_MS,
+  SIZE_ATTEMPT_MS,
+  TriageSchema,
+  triageFinding,
+  describeEscalation,
+  RequestSizeSchema,
+  describeSizeDoubt,
+  sizeRequest
+};

package/dist/chunk-B67BK5GQ.js

@@ -0,0 +1,34 @@
+// src/session/atomic.ts
+import { rename, rm, writeFile } from "fs/promises";
+import { renameSync, rmSync, writeFileSync } from "fs";
+var seq = 0;
+var tmpName = (path) => `${path}.${process.pid}.${seq++}.tmp`;
+async function writeAtomic(path, data) {
+  const tmp = tmpName(path);
+  try {
+    await writeFile(tmp, data, "utf8");
+    await rename(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true }).catch(() => {
+    });
+    throw e;
+  }
+}
+function writeAtomicSync(path, data) {
+  const tmp = tmpName(path);
+  try {
+    writeFileSync(tmp, data, "utf8");
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw e;
+  }
+}
+
+export {
+  writeAtomic,
+  writeAtomicSync
+};

package/dist/chunk-BY4DP7IE.js

@@ -0,0 +1,20 @@
+// src/skills/frontmatter.ts
+function parseFrontmatter(raw) {
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return { body: raw };
+  const [, fm, body] = m;
+  const read = (key) => {
+    const line = fm.split(/\r?\n/).find((l) => l.trimStart().startsWith(`${key}:`));
+    if (!line) return void 0;
+    let v = line.slice(line.indexOf(":") + 1).trim();
+    if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+      v = v.slice(1, -1);
+    }
+    return v;
+  };
+  return { name: read("name"), description: read("description"), body };
+}
+
+export {
+  parseFrontmatter
+};

package/dist/chunk-DKVIN43T.js

@@ -0,0 +1,54 @@
+import {
+  arrayField,
+  objectField,
+  patchConfig
+} from "./chunk-H2FDGPVW.js";
+
+// src/config/save-skills.ts
+async function saveSkillSource(home, src) {
+  return patchConfig(home, (current) => {
+    const sources = arrayField(current, "skillSources").filter(
+      (s) => !(typeof s === "object" && s !== null && s.name === src.name)
+    );
+    return { ...current, skillSources: [...sources, src] };
+  });
+}
+async function removeSkillSource(home, name) {
+  let found = false;
+  const ok = await patchConfig(home, (current) => {
+    const sources = arrayField(current, "skillSources");
+    const kept = sources.filter((s) => {
+      const match = typeof s === "object" && s !== null && s.name === name;
+      if (match) found = true;
+      return !match;
+    });
+    return found ? { ...current, skillSources: kept } : void 0;
+  });
+  return ok && found;
+}
+async function saveRoleSkills(home, assignments) {
+  const names = Object.keys(assignments);
+  if (!names.length) return 0;
+  const ok = await patchConfig(home, (current) => {
+    const roles = objectField(current, "roles");
+    for (const role of names) {
+      const prev = typeof roles[role] === "object" && roles[role] !== null ? roles[role] : {};
+      roles[role] = { ...prev, skills: [...assignments[role]] };
+    }
+    return { ...current, roles };
+  });
+  return ok ? names.length : 0;
+}
+async function saveMcpServer(home, name, spec) {
+  return patchConfig(home, (current) => ({
+    ...current,
+    mcp: { ...objectField(current, "mcp"), [name]: spec }
+  }));
+}
+
+export {
+  saveSkillSource,
+  removeSkillSource,
+  saveRoleSkills,
+  saveMcpServer
+};

package/dist/chunk-DTWKSZXY.js

@@ -0,0 +1,162 @@
+import {
+  hashContent,
+  traceDir
+} from "./chunk-FFYBY2NA.js";
+
+// src/engine/project-brief.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFileSync } from "fs";
+import { join } from "path";
+var BRIEF_FILE = "PROJECT.md";
+var BRIEF_META = "PROJECT.json";
+var DOC_PATTERNS = [
+  /^readme(\.md)?$/i,
+  /**
+   * A project's own index, before anything else under `docs/`.
+   *
+   * Selection was pattern order then file order, so `docs/` was read alphabetically: on a real repository
+   * that meant the brief would have been built from BACKUP_STRATEGY, DEPLOYMENT_GUIDE and an e-invoicing
+   * appendix, while `docs/architecture/00-INDEX.md` — the document that actually says what the system is —
+   * never reached the budget. An index is the one document written to be read first.
+   */
+  /(^|\/)(00-)?index\.md$/i,
+  /(^|\/)(architecture|overview)\.md$/i,
+  /^(docs?|specs?)\/.*\.mde?$/i,
+  /^\.specify\/memory\/constitution\.md$/i,
+  /^specs\/[^/]+\/(spec|brainstorm|plan)\.md$/i,
+  /^(contributing|architecture|design|domain|glossary)\.md$/i,
+  /^docs?\/.*\.(md|txt)$/i
+];
+var MAX_BRIEF_INPUT_CHARS = 12e4;
+var MAX_DOC_CHARS = 2e4;
+function briefPath(cwd) {
+  return join(traceDir(cwd), BRIEF_FILE);
+}
+function selectDocs(files, excluded = /* @__PURE__ */ new Set()) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const pattern of DOC_PATTERNS) {
+    for (const f of files) {
+      if (seen.has(f) || !pattern.test(f)) continue;
+      if (/(^|\/)(node_modules|dist|build|vendor|\.horsecode|graphify-out|CHANGELOG)/i.test(f)) continue;
+      if (excluded.has(f)) continue;
+      seen.add(f);
+      out.push(f);
+    }
+  }
+  return out;
+}
+async function gatherBriefInput(cwd, files) {
+  const picked = selectDocs(files, await ourOwnOutput(cwd));
+  const sources = [];
+  let chars = 0;
+  for (const file of picked) {
+    if (chars >= MAX_BRIEF_INPUT_CHARS) break;
+    let text;
+    try {
+      text = await readFile(join(cwd, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (!text.trim()) continue;
+    const clipped = text.length > MAX_DOC_CHARS ? `${text.slice(0, MAX_DOC_CHARS)}
+\u2026[truncated]` : text;
+    sources.push({ file, text: clipped });
+    chars += clipped.length;
+  }
+  if (!sources.length) return void 0;
+  return { sources, hash: hashContent(sources.map((s) => `${s.file}:${s.text}`).join("\n")), chars };
+}
+async function ourOwnOutput(cwd) {
+  const out = /* @__PURE__ */ new Set();
+  try {
+    const { loadTraceIndex, traceRootRel } = await import("./trace-ZMB7LT7W.js");
+    const root = traceRootRel().replace(/\\/g, "/");
+    out.add(`${root}/PROJECT.md`);
+    out.add(`${root}/PROJECT.json`);
+    const index = await loadTraceIndex(cwd);
+    for (const [file, rec] of Object.entries(index.traces)) if (!rec.doc) out.add(`${root}/${file}.md`);
+  } catch {
+  }
+  return out;
+}
+function briefPrompt(input) {
+  const body = input.sources.map((s) => `### ${s.file}
+${s.text}`).join("\n\n");
+  return `Read this project's own documentation and write the briefing an engineer would want on their first day, before touching any code.
+
+At most 400 words, under these exact headings:
+**What it is** \u2014 the product, in one or two sentences: what it does and for whom.
+**Domain concepts** \u2014 the nouns this project's people use and what each one means here. Only terms the documents actually define or use consistently; this is a glossary, not a summary.
+**Rules that matter** \u2014 business rules, constraints and invariants stated in the documents that code must not violate. Quote the constraint, not your paraphrase of its importance.
+**Deliberate choices** \u2014 decisions the documents record along with their reasons, so they are not undone by someone who never saw the reason.
+
+Rules:
+- Use ONLY what these documents state. If they do not say who the users are, do not invent them.
+- Omit a heading entirely rather than filling it with something plausible.
+- No preamble and no closing summary.
+
+Documents:
+
+${body}`;
+}
+async function saveBrief(cwd, body, meta) {
+  await mkdir(traceDir(cwd), { recursive: true });
+  await writeFile(briefPath(cwd), `# Project brief
+
+${body.trim()}
+`, "utf8");
+  await writeFile(join(traceDir(cwd), BRIEF_META), `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+}
+async function loadBriefMeta(cwd) {
+  try {
+    return JSON.parse(await readFile(join(traceDir(cwd), BRIEF_META), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readBriefSync(cwd) {
+  try {
+    return readFileSync(briefPath(cwd), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var MAX_BRIEF_IN_PROMPT = 1200;
+function briefForPrompt(cwd) {
+  const b = readBriefSync(cwd);
+  if (!b) return void 0;
+  const body = b.replace(/^# Project brief\s*/, "").trim();
+  return body.length > MAX_BRIEF_IN_PROMPT ? `${body.slice(0, MAX_BRIEF_IN_PROMPT)}\u2026` : body;
+}
+async function briefStatus(cwd, files) {
+  const meta = await loadBriefMeta(cwd);
+  if (!meta || !readBriefSync(cwd)) return { built: false, stale: false, sources: [], changed: [] };
+  const now = await gatherBriefInput(cwd, files);
+  if (!now) return { built: true, stale: false, sources: meta.sources, ...meta.writtenAt ? { builtAt: meta.writtenAt } : {}, changed: [] };
+  const stale = now.hash !== meta.hash;
+  const before = new Set(meta.sources);
+  const changed = stale ? [
+    ...now.sources.filter((s) => !before.has(s.file)).map((s) => s.file),
+    ...meta.sources.filter((f) => !now.sources.some((s) => s.file === f)).map((f) => `${f} (gone)`)
+  ] : [];
+  return {
+    built: true,
+    stale,
+    sources: meta.sources,
+    ...meta.writtenAt ? { builtAt: meta.writtenAt } : {},
+    // An edit inside an unchanged set of files changes the hash without changing the list; say so rather
+    // than reporting an empty reason.
+    changed: stale && !changed.length ? ["the documents were edited"] : changed
+  };
+}
+
+export {
+  gatherBriefInput,
+  briefPrompt,
+  saveBrief,
+  readBriefSync,
+  briefForPrompt,
+  briefStatus
+};