@irythill/orq 0.0.0-stage → 0.1.0

package/dist/agents.js

@@ -0,0 +1,202 @@
+import { m } from "./i18n.js";
+const NOMCP_CODEX = "-c mcp_servers.plane.enabled=false -c mcp_servers.shadcn.enabled=false";
+const CLAUDE = "claude -p --strict-mcp-config --output-format stream-json --verbose [--model {model}] --effort {effort:low}";
+const OPENCODE = "opencode run --standalone --format json [-m {model}]"; // v2: effort goes in the model, "provider/model#variant"
+const AGY = "agy --output-format stream-json --sandbox [--model {model}] [--effort {effort}]";
+const COPILOT = "-s -C {dir} --disable-builtin-mcps --disable-mcp-server plane --allow-tool 'shell(git diff:*)' " +
+    "--allow-tool 'shell(git log:*)' --allow-tool 'shell(git show:*)' --deny-tool write [--model {model}] " +
+    "[--reasoning-effort {effort}] -p {prompt_text}";
+/** What herdr-agent did per agent, as templates. */
+export const BUILTIN_AGENTS = {
+    claude: {
+        // stream-json shows live progress; a fixed --session-id lets the follow-up --resume. No MCP; the child must not
+        // report state on the conductor's herdr pane.
+        run: `${CLAUDE} --session-id {session} {mode}`, resume: `${CLAUDE} --resume {session} {mode}`,
+        readonly: "--permission-mode plan", write: "--permission-mode auto --add-dir {gitdir}",
+        stdin: true, format: "claude", session: "uuid", accounts: true, unset_env: ["HERDR_PANE_ID"],
+    },
+    codex: {
+        // Codex treats any .git inside a writable root as read only: the folders a commit needs are granted one by one.
+        // Read only: its read-only sandbox doesn't even let jest write its cache, so it runs on a throwaway worktree.
+        run: `codex exec [-m {model}] -c model_reasoning_effort={effort:low} -s workspace-write -C {dir} ` +
+            `--skip-git-repo-check {mode} ${NOMCP_CODEX} -o {out} -`,
+        resume: `codex exec resume {session} -c model_reasoning_effort={effort:low} ` +
+            `-c sandbox_workspace_write.writable_roots={gitroots_json} ${NOMCP_CODEX} -o {out} -`,
+        readonly: "", write: "[--add-dir {gitroots}]", stdin: true, format: "codex", answer: "file", throwaway: true,
+    },
+    opencode: {
+        // Permissions and MCPs off via OPENCODE_CONFIG_CONTENT. Headless has nobody to approve, so write = --auto (only
+        // ever in a worktree) and read only = throwaway worktree with the edit tool denied.
+        run: `${OPENCODE} {mode} {prompt_text}`, resume: `${OPENCODE} -s {session} {mode} {prompt_text}`, readonly: "", write: "--auto",
+        format: "opencode", throwaway: true, env: { OPENCODE_CONFIG_CONTENT: "{opencode_config}" },
+    },
+    antigravity: {
+        // --sandbox + accept-edits (no skip-permissions); headless denies commands outside agy's allowlist, so in practice
+        // it reviews. The prompt goes in a file in its folder (excluded from git) and -p only says "read it".
+        run: `${AGY} {mode} -p {prompt_hint}`, resume: `${AGY} --conversation {session} {mode} -p {prompt_hint}`,
+        readonly: "--mode plan", write: "--mode accept-edits --add-dir {gitdir}",
+        format: "antigravity", throwaway: true, prompt_in_dir: true,
+    },
+    copilot: {
+        // Second opinion, always read only: git reads allowed, anything else denied by -p without asking.
+        run: `copilot --session-id={session} ${COPILOT}`, resume: `copilot --resume={session} ${COPILOT}`,
+        readonly: "", write: false, session: "uuid",
+    },
+};
+export const ALIASES = { agy: "antigravity" };
+/** The definition of `name`: built-in defaults, then [agents.<name>] from the config. */
+export function agentDef(cfg, name) {
+    const user = (cfg.agents ?? {})[name] ?? {};
+    const def = { ...(BUILTIN_AGENTS[name] ?? {}), ...user };
+    if (typeof def.run !== "string")
+        throw new Error(m(`unknown agent: ${name} (built in: ${Object.keys(BUILTIN_AGENTS).join(", ")}; others need agents.${name}.run in the config)`, `agente desconhecido: ${name} (embutidos: ${Object.keys(BUILTIN_AGENTS).join(", ")}; outros precisam de agents.${name}.run no config)`));
+    return def;
+}
+/** Split a template into words, remembering which [group] each belongs to. */
+export function tokenize(t) {
+    const out = [];
+    let cur = "", q = "", has = false, g = -1, gid = 0, close = false;
+    const push = () => {
+        if (has)
+            out.push({ text: cur, group: g });
+        if (close) {
+            g = -1;
+            close = false;
+        }
+        cur = "";
+        has = false;
+    };
+    for (const c of t) {
+        if (q) {
+            if (c === q)
+                q = "";
+            else
+                cur += c;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            q = c;
+            has = true;
+            continue;
+        }
+        if (/\s/.test(c)) {
+            push();
+            continue;
+        }
+        if (c === "[" && !has && g < 0) {
+            g = gid++;
+            continue;
+        }
+        if (c === "]" && g >= 0) {
+            close = true;
+            push();
+            continue;
+        }
+        cur += c;
+        has = true;
+    }
+    push();
+    return out;
+}
+const PH = /\{(\w+)(?::([^}]*))?\}/g;
+function expandWords(ws, vars, optional) {
+    const names = ws.flatMap((w) => [...w.matchAll(PH)].map((x) => x[1]));
+    for (const n of names)
+        if (!(n in vars))
+            throw new Error(m(`unknown placeholder {${n}}`, `placeholder desconhecido {${n}}`));
+    const list = optional ? names.find((n) => Array.isArray(vars[n])) : undefined;
+    if (list)
+        return vars[list].flatMap((v) => expandWords(ws, { ...vars, [list]: v }, true));
+    const out = [];
+    for (const w of ws) {
+        const whole = /^\{(\w+)(?::([^}]*))?\}$/.exec(w);
+        const wv = whole ? vars[whole[1]] : undefined;
+        if (Array.isArray(wv)) {
+            out.push(...wv);
+            continue;
+        }
+        let empty = false;
+        const s = w.replace(PH, (_, n, d) => {
+            const v = vars[n], x = (Array.isArray(v) ? v.join(" ") : v) || d || "";
+            if (!x)
+                empty = true;
+            return x;
+        });
+        if (empty && optional)
+            return [];
+        if (!(whole && !s))
+            out.push(s);
+    }
+    return out;
+}
+/** Template → argv. */
+export function expandTemplate(t, vars) {
+    const words = tokenize(t), out = [];
+    for (let i = 0; i < words.length;) {
+        const g = words[i].group;
+        let j = i + 1;
+        if (g >= 0)
+            while (j < words.length && words[j].group === g)
+                j++;
+        out.push(...expandWords(words.slice(i, j).map((w) => w.text), vars, g >= 0));
+        i = j;
+    }
+    return out;
+}
+/** Placeholders inside a single string (env values): no splitting. */
+export const expandString = (s, vars) => s.replace(PH, (_, n, d) => { const v = vars[n]; return (Array.isArray(v) ? v.join(" ") : v) || d || ""; });
+const json = (l) => { try {
+    const v = JSON.parse(l);
+    return v && typeof v === "object" ? v : undefined;
+}
+catch {
+    return undefined;
+} };
+const jsonLines = (log) => log.split(/\r?\n/).filter((l) => l.startsWith("{")).map(json).filter((x) => !!x);
+const lastOf = (xs) => xs.length ? xs[xs.length - 1] : undefined;
+export const FORMATS = {
+    text: { show: (l) => `${l}\n`, finish: (_log, stdout) => ({ answer: stdout }) },
+    codex: { show: (l) => `${l}\n`, finish: (log) => ({ session: /session id:?\s*(\S+)/.exec(log)?.[1] }) },
+    claude: {
+        show(l) {
+            const j = json(l);
+            if (j?.type !== "assistant")
+                return undefined;
+            const parts = (j.message?.content ?? []).map((c) => c.type === "text" ? c.text : c.type === "tool_use" ? `· ${c.name}` : undefined)
+                .filter((x) => x !== undefined);
+            return parts.length ? parts.join("\n") + "\n" : undefined;
+        },
+        finish: (log) => ({ answer: lastOf(jsonLines(log).filter((j) => j.type === "result").map((j) => String(j.result ?? ""))) ?? "" }),
+    },
+    opencode: {
+        show(l) {
+            const j = json(l);
+            return j?.type === "text" ? `${j.part?.text ?? ""}\n` : j?.type === "tool_use" ? `· ${j.part?.tool ?? "tool"}\n` : undefined;
+        },
+        finish(log) {
+            const js = jsonLines(log);
+            return { session: lastOf(js.filter((j) => j.sessionID).map((j) => String(j.sessionID))),
+                answer: lastOf(js.filter((j) => j.type === "text").map((j) => String(j.part?.text ?? ""))) ?? "" };
+        },
+        idle: (last) => { const j = json(last); return j?.type === "step_finish" && j.part?.reason === "stop"; },
+    },
+    antigravity: {
+        show(l) {
+            const j = json(l), s = j?.event === "step_update" ? j.step_update : undefined;
+            if (!s)
+                return undefined;
+            if (s.step_type === "agent_response")
+                return s.text_delta || undefined;
+            return s.step_type === "tool" && s.state === "DONE" ? "\n· tool\n" : undefined;
+        },
+        finish(log) {
+            const res = jsonLines(log).filter((j) => j.event === "result").map((j) => j.result ?? {});
+            let answer = lastOf(res.map((r) => String(r.response ?? ""))) ?? "";
+            // An agy error (e.g. a denied command) is a failure, even with an answer.
+            const errs = log.split(/\r?\n/).filter((l) => l.startsWith("jetski: "));
+            if (errs.length)
+                answer += (answer ? "\n" : "") + errs.join("\n") + "\n";
+            return { session: lastOf(res.map((r) => r.conversation_id).filter(Boolean)), answer, rc: errs.length ? 3 : undefined };
+        },
+    },
+};

package/dist/banner.js

@@ -0,0 +1,87 @@
+// The orc conductor: ASCII art shown when orq starts in a real terminal (`orq`, `orq --version`, `orq setup`).
+// Never printed when stdout is not a TTY, so conductors and scripts reading orq's output never see it.
+// Colors are painted over the ASCII (24-bit when COLORTERM says so, else the 16 basic colors); NO_COLOR turns them off.
+import { readFileSync } from "node:fs";
+import { m } from "./i18n.js";
+export const ORC = [
+    "            (@)                      *",
+    "        .-'''''''-.                 /",
+    "       /  /==^==\\  \\               /",
+    "  /\\  | [ (o) (o) ] |  /\\       _/",
+    "  \\ '-|     (_)     |-' /      (_)",
+    "   '-.| ^         ^ |.-'       | |",
+    "      \\ '-._____.-' /         / /",
+    "   _.--'-._______.-'--.______/ /",
+    "  /    /|  \\>o</  |\\    \\    /",
+    " |    / |   \\|/   | \\       |",
+];
+const RGB = {
+    skin: [155, 209, 74], brow: [106, 165, 49], eye: [214, 52, 40], white: [240, 236, 224],
+    coat: [150, 146, 170], hair: [120, 116, 140], wood: [190, 120, 60], tip: [226, 178, 70],
+};
+const BASIC = { skin: 92, brow: 32, eye: 91, white: 97, coat: 37, hair: 90, wood: 33, tip: 93 };
+/** Which part of the orc a character belongs to (row, column). */
+export function tone(y, x, ch) {
+    if (ch === " ")
+        return undefined;
+    if (y === 0 && x < 20)
+        return "hair";
+    if (x >= 29)
+        return y <= 3 ? (ch === "*" ? "tip" : "wood") : y >= 8 ? "coat" : "skin";
+    if (y === 3 && ch === "o")
+        return "eye";
+    if (y === 5 && ch === "^")
+        return "white";
+    if (y === 2 && (ch === "=" || ch === "^"))
+        return "brow";
+    if (y >= 7)
+        return y >= 8 && x >= 10 && x <= 16 ? (">o<".includes(ch) ? "eye" : "white") : "coat";
+    return "skin";
+}
+export function colorMode(env = process.env, tty = Boolean(process.stdout.isTTY)) {
+    if (!tty || env.NO_COLOR)
+        return "none";
+    return /truecolor|24bit/i.test(env.COLORTERM ?? "") || env.WT_SESSION ? "true" : "basic";
+}
+const paint = (t, s, mode) => mode === "none" ? s
+    : mode === "true" ? `\x1b[38;2;${RGB[t].join(";")}m${s}\x1b[0m` : `\x1b[${BASIC[t]}m${s}\x1b[0m`;
+export function version() {
+    try {
+        return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+    }
+    catch {
+        return "?";
+    }
+}
+/** Lines shown next to the orc: version and who plays which role. */
+export function infoLines(cfg) {
+    const roles = (cfg.roles ?? {});
+    const agents = Object.keys((cfg.agents ?? {}));
+    const who = (r) => r?.agent ? String(r.agent) : r?.pool ? `auto (${r.pool.join(", ")})` : undefined;
+    const lines = [`orq ${version()}`, m("orchestrate coding agents", "orquestrando agentes de código"), ""];
+    if (!agents.length)
+        return [...lines, m("no agents yet — run `orq setup`", "nenhum agente ainda — rode `orq setup`")];
+    const conductor = who(roles.conductor), primary = who(roles.primary), reviewer = who(roles.reviewer);
+    if (conductor)
+        lines.push(`${m("conductor", "conductor")}  ${conductor}`);
+    if (primary)
+        lines.push(`${m("primary", "principal")}  ${primary}`);
+    if (reviewer)
+        lines.push(`${m("reviewer", "revisor")}    ${reviewer}`);
+    if (!primary && !reviewer)
+        lines.push(`${m("agents", "agentes")}    ${agents.join(", ")}`);
+    return [...lines, "", "orq setup · orq pick · orq --help"];
+}
+/** The orc with `info` beside it, or "" when stdout is not a terminal. */
+export function banner(info, mode = colorMode(), tty = Boolean(process.stdout.isTTY)) {
+    if (!tty)
+        return "";
+    const w = Math.max(...ORC.map((l) => l.length)) + 4;
+    const top = Math.max(0, Math.floor((ORC.length - info.length) / 2));
+    return ORC.map((line, y) => {
+        const art = [...line].map((ch, x) => { const t = tone(y, x, ch); return t ? paint(t, ch, mode) : ch; }).join("");
+        const i = info[y - top];
+        const text = i === undefined ? "" : y === top && mode !== "none" ? `\x1b[1m${i}\x1b[0m` : i;
+        return (art + " ".repeat(w - line.length) + text).trimEnd();
+    }).join("\n") + "\n";
+}

package/dist/cli.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// orq — one CLI for the orchestration. Subcommands are being ported from setup/ one by one
+// (docs/portability.md); the old names (orq-config, orq-set, orq-lang, orq-block) call into this.
+import { ConfigError, getPath, loadConfig } from "./config.js";
+import { banner, infoLines, version } from "./banner.js";
+import { detectLang, m, setLang } from "./i18n.js";
+import { agent, USAGE as AGENT } from "./commands/agent.js";
+import { board, USAGE as BOARD } from "./commands/board.js";
+import { baseline, USAGE as BASELINE } from "./commands/baseline.js";
+import { block, USAGE as BLOCK } from "./commands/block.js";
+import { claim, USAGE as CLAIM } from "./commands/claim.js";
+import { completion, USAGE as COMPLETION } from "./commands/completion.js";
+import { config, USAGE as CONFIG } from "./commands/config.js";
+import { deps, USAGE as DEPS } from "./commands/deps.js";
+import { instructions, USAGE as INSTRUCTIONS } from "./commands/instructions.js";
+import { lang, USAGE as LANG } from "./commands/lang.js";
+import { lock, USAGE as LOCK } from "./commands/lock.js";
+import { pick, USAGE as PICK } from "./commands/pick.js";
+import { quota, USAGE as QUOTA } from "./commands/quota.js";
+import { run, USAGE as RUN } from "./commands/run.js";
+import { set, USAGE as SET } from "./commands/set.js";
+import { setup, USAGE as SETUP } from "./commands/setup.js";
+import { stats, USAGE as STATS } from "./commands/stats.js";
+import { verify, USAGE as VERIFY } from "./commands/verify.js";
+import { wait, USAGE as WAIT } from "./commands/wait.js";
+const COMMANDS = { config, set, board, lang, block, quota, pick, stats, setup, lock, claim, deps, run, agent, wait, instructions, verify, baseline,
+    completion: (a) => completion(a, Object.keys(COMMANDS)) };
+const usage = () => `orq <command> [args]
+
+${SETUP}
+${CONFIG}
+${SET}
+${LANG}
+${QUOTA}
+${PICK}
+${STATS}
+${BOARD}
+${LOCK}
+${RUN}
+${AGENT}
+${WAIT}
+${VERIFY}
+${BASELINE}
+${INSTRUCTIONS}
+${CLAIM}
+${DEPS}
+${COMPLETION}
+${BLOCK.split("\n")[0]}
+  (orq block --help ${m("for more", "para mais")})`;
+async function main(argv) {
+    try {
+        setLang(detectLang(getPath(loadConfig().cfg, "ui.lang")));
+    }
+    catch { /* a broken config is reported by the command itself */ }
+    const [cmd, ...rest] = argv;
+    // The orc greets only a person at a terminal; scripts and conductors (no TTY) get the plain output.
+    const hello = () => { try {
+        process.stdout.write(banner(infoLines(loadConfig().cfg)) + (process.stdout.isTTY ? "\n" : ""));
+    }
+    catch { /* broken config: skip */ } };
+    if (cmd === "-v" || cmd === "--version") {
+        if (process.stdout.isTTY)
+            hello();
+        else
+            console.log(version());
+        return 0;
+    }
+    if (!cmd && process.stdout.isTTY) {
+        hello();
+        console.log(usage());
+        return 0;
+    }
+    if (!cmd || cmd === "-h" || cmd === "--help") {
+        console.log(usage());
+        return cmd ? 0 : 2;
+    }
+    const run = COMMANDS[cmd];
+    if (!run) {
+        console.error(`${m("unknown command", "comando desconhecido")}: ${cmd}\n\n${usage()}`);
+        return 2;
+    }
+    try {
+        return await run(rest);
+    }
+    catch (e) {
+        console.error(e instanceof ConfigError ? e.message : `orq ${cmd}: ${e.message}`);
+        return 2;
+    }
+}
+process.exitCode = await main(process.argv.slice(2));