@vornicx/origin 0.1.0

package/dist/chunk-77G3SI57.js

@@ -0,0 +1,1119 @@
+import { readFile, mkdir, appendFile, readdir, stat } from 'fs/promises';
+import { join, relative, resolve, sep, isAbsolute, extname } from 'path';
+import { randomUUID, createHash } from 'crypto';
+import { stdout, stdin } from 'process';
+import { createInterface } from 'readline/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { z } from 'zod';
+
+// src/context/ignore.ts
+function parseIgnore(content) {
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+var Ignore = class {
+  rules = [];
+  add(patterns) {
+    for (const pattern of patterns) {
+      const rule = compile(pattern);
+      if (rule) this.rules.push(rule);
+    }
+    return this;
+  }
+  /** Returns true if `path` (POSIX, relative to root) is ignored. Last match wins. */
+  ignores(path, isDir) {
+    let ignored = false;
+    for (const rule of this.rules) {
+      if (rule.dirOnly && !isDir) continue;
+      if (rule.regex.test(path)) ignored = !rule.negated;
+    }
+    return ignored;
+  }
+};
+function compile(raw) {
+  let pattern = raw.trim();
+  if (!pattern || pattern.startsWith("#")) return null;
+  let negated = false;
+  if (pattern.startsWith("!")) {
+    negated = true;
+    pattern = pattern.slice(1);
+  }
+  let dirOnly = false;
+  if (pattern.endsWith("/")) {
+    dirOnly = true;
+    pattern = pattern.slice(0, -1);
+  }
+  let anchored = false;
+  if (pattern.startsWith("/")) {
+    anchored = true;
+    pattern = pattern.slice(1);
+  } else if (pattern.includes("/")) {
+    anchored = true;
+  }
+  if (!pattern) return null;
+  const prefix = anchored ? "^" : "(?:^|/)";
+  const regex = new RegExp(`${prefix}${globToRegex(pattern)}(?:/.*)?$`);
+  return { negated, dirOnly, regex };
+}
+function globToRegex(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          out += "(?:.*/)?";
+          i += 2;
+        } else {
+          out += ".*";
+          i += 1;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+    } else {
+      out += escapeRegexChar(c);
+    }
+  }
+  return out;
+}
+function escapeRegexChar(ch) {
+  return /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+var DEFAULT_IGNORE_DIRS = ["node_modules", ".git", ".origin", "dist", "coverage"];
+var DEFAULT_IGNORE_FILES = [".gitignore", ".originignore"];
+var DEFAULT_MAX_FILES = 2e3;
+var LANGUAGE_BY_EXT = {
+  ts: "TypeScript",
+  tsx: "TypeScript",
+  js: "JavaScript",
+  jsx: "JavaScript",
+  mjs: "JavaScript",
+  cjs: "JavaScript",
+  py: "Python",
+  rs: "Rust",
+  go: "Go",
+  java: "Java",
+  rb: "Ruby",
+  php: "PHP",
+  c: "C",
+  h: "C",
+  cpp: "C++",
+  cs: "C#",
+  swift: "Swift",
+  kt: "Kotlin",
+  sql: "SQL",
+  sh: "Shell",
+  json: "JSON",
+  yaml: "YAML",
+  yml: "YAML",
+  toml: "TOML",
+  md: "Markdown",
+  html: "HTML",
+  css: "CSS"
+};
+var ContextEngine = class {
+  async scan(options = {}) {
+    const root = options.root ?? process.cwd();
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const ignoreFiles = options.ignoreFiles ?? DEFAULT_IGNORE_FILES;
+    const ignore = new Ignore().add(DEFAULT_IGNORE_DIRS.map((d) => `${d}/`));
+    for (const name of ignoreFiles) {
+      try {
+        ignore.add(parseIgnore(await readFile(join(root, name), "utf8")));
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+    }
+    const files = [];
+    let truncated = false;
+    const walk = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (truncated) return;
+        if (entry.isSymbolicLink()) continue;
+        const abs = join(dir, entry.name);
+        const rel = toPosix(relative(root, abs));
+        if (entry.isDirectory()) {
+          if (ignore.ignores(rel, true)) continue;
+          await walk(abs);
+        } else if (entry.isFile()) {
+          if (ignore.ignores(rel, false)) continue;
+          if (files.length >= maxFiles) {
+            truncated = true;
+            return;
+          }
+          const info = await stat(abs);
+          const ext = extname(entry.name).slice(1).toLowerCase();
+          const language = LANGUAGE_BY_EXT[ext];
+          files.push(
+            language ? { path: rel, size: info.size, ext, language } : { path: rel, size: info.size, ext }
+          );
+        }
+      }
+    };
+    await walk(root);
+    const languages = {};
+    for (const file of files) {
+      if (file.language) languages[file.language] = (languages[file.language] ?? 0) + 1;
+    }
+    const bundle = {
+      root,
+      files,
+      languages,
+      tools: options.tools ?? [],
+      truncated,
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (options.goal) bundle.intent = parseIntent(options.goal);
+    return bundle;
+  }
+};
+var ACTION_VERBS = /* @__PURE__ */ new Set([
+  "add",
+  "analyze",
+  "build",
+  "configure",
+  "create",
+  "delete",
+  "deploy",
+  "document",
+  "fix",
+  "generate",
+  "implement",
+  "install",
+  "integrate",
+  "investigate",
+  "migrate",
+  "optimize",
+  "plan",
+  "prepare",
+  "publish",
+  "refactor",
+  "release",
+  "remove",
+  "review",
+  "summarize",
+  "test",
+  "update",
+  "write"
+]);
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "into",
+  "your",
+  "you",
+  "are",
+  "was",
+  "has",
+  "have",
+  "will",
+  "all",
+  "any",
+  "our",
+  "their",
+  "his",
+  "her",
+  "its"
+]);
+function parseIntent(goal) {
+  const words = goal.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter(Boolean);
+  const verbs = unique(words.filter((w) => ACTION_VERBS.has(w)));
+  const keywords = unique(
+    words.filter((w) => w.length > 3 && !STOPWORDS.has(w) && !ACTION_VERBS.has(w))
+  ).slice(0, 12);
+  return { goal: goal.trim(), verbs, keywords };
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+function toPosix(p) {
+  return p.split(sep).join("/");
+}
+
+// src/memory/store.ts
+var InMemoryStore = class {
+  records = /* @__PURE__ */ new Map();
+  async all() {
+    return [...this.records.values()];
+  }
+  async get(id) {
+    return this.records.get(id) ?? null;
+  }
+  async put(record) {
+    this.records.set(record.id, record);
+  }
+  async delete(id) {
+    return this.records.delete(id);
+  }
+  async clear() {
+    this.records.clear();
+  }
+};
+var DEFAULT_RECALL_LIMIT = 6;
+var RECENCY_HALF_LIFE_DAYS = 30;
+var Memory = class {
+  store;
+  now;
+  constructor(options = {}) {
+    this.store = options.store ?? new InMemoryStore();
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async remember(input) {
+    const content = input.content?.trim();
+    if (!content) throw new Error("Memory.remember: `content` is required");
+    const ts = this.now().toISOString();
+    const record = {
+      id: randomUUID(),
+      content,
+      kind: input.kind ?? "note",
+      importance: clampImportance(input.importance ?? 1),
+      source: input.source,
+      metadata: input.metadata ?? {},
+      createdAt: ts,
+      updatedAt: ts
+    };
+    await this.store.put(record);
+    return record;
+  }
+  async recall(query, options = {}) {
+    const limit = options.limit ?? DEFAULT_RECALL_LIMIT;
+    if (this.store.recall) return this.store.recall(query, { ...options, limit });
+    const all = await this.store.all();
+    const nowMs = this.now().getTime();
+    const terms = tokenize(query);
+    return all.filter((r) => options.kind ? r.kind === options.kind : true).filter((r) => options.minImportance ? r.importance >= options.minImportance : true).map((r) => ({ ...r, score: scoreRecord(r, terms, nowMs) })).sort((a, b) => b.score - a.score || b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit);
+  }
+  async list(options = {}) {
+    const all = await this.store.all();
+    const filtered = options.kind ? all.filter((r) => r.kind === options.kind) : all;
+    filtered.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return options.limit ? filtered.slice(0, options.limit) : filtered;
+  }
+  async update(id, patch) {
+    const existing = await this.store.get(id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      content: patch.content?.trim() || existing.content,
+      importance: patch.importance !== void 0 ? clampImportance(patch.importance) : existing.importance,
+      metadata: patch.metadata ? { ...existing.metadata, ...patch.metadata } : existing.metadata,
+      updatedAt: this.now().toISOString()
+    };
+    await this.store.put(updated);
+    return updated;
+  }
+  async forget(id) {
+    return this.store.delete(id);
+  }
+  async forgetAll() {
+    return this.store.clear();
+  }
+  /** All records, oldest first — for backup/inspection. */
+  async export() {
+    const all = await this.store.all();
+    return all.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  /** Recalled memories rendered as a system-prompt block (Apollo-compatible). */
+  async formatBlock(query, options = {}) {
+    return formatMemoriesBlock(await this.recall(query, options));
+  }
+};
+function clampImportance(n) {
+  if (!Number.isFinite(n)) return 1;
+  return Math.min(5, Math.max(1, Math.round(n)));
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2);
+}
+function scoreRecord(record, queryTerms, nowMs) {
+  const haystack = new Set(tokenize(record.content));
+  let overlap = 0;
+  for (const term of queryTerms) if (haystack.has(term)) overlap += 1;
+  const relevance = queryTerms.length > 0 ? overlap / queryTerms.length : 0;
+  const importance = (record.importance - 1) / 4;
+  const ageDays = Math.max(0, (nowMs - Date.parse(record.updatedAt)) / 864e5);
+  const recency = Math.exp(-ageDays / RECENCY_HALF_LIFE_DAYS);
+  return relevance * 1 + importance * 0.3 + recency * 0.2;
+}
+function formatMemoriesBlock(memories) {
+  if (memories.length === 0) return "";
+  const lines = memories.map((m) => {
+    const date = m.createdAt.slice(0, 10);
+    return `- [${m.kind} \xB7 ${date}] ${m.content.replace(/\s+/g, " ").trim().slice(0, 600)}`;
+  });
+  return [
+    "# Origin memory",
+    "Relevant things you remember about this user. Use them silently to stay consistent. Do not list them back unless asked.",
+    ...lines
+  ].join("\n");
+}
+var SECRET_KEY_RE = /(api[-_]?key|secret|token|password|passwd|authorization|auth|bearer|credential|private[-_]?key)/i;
+var SECRET_VALUE_RES = [
+  /\bsk-[A-Za-z0-9]{16,}\b/g,
+  // OpenAI-style
+  /\bBearer\s+[A-Za-z0-9._-]{8,}\b/gi,
+  // Authorization headers
+  /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+  // GitHub tokens
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g
+  // Slack tokens
+];
+function redactValue(value, keyIsSecret) {
+  if (typeof value === "string") {
+    if (keyIsSecret) return "[redacted]";
+    let out = value;
+    for (const re of SECRET_VALUE_RES) out = out.replace(re, "[redacted]");
+    return out;
+  }
+  if (Array.isArray(value)) return value.map((v) => redactValue(v, false));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = redactValue(v, SECRET_KEY_RE.test(k));
+    return out;
+  }
+  return value;
+}
+var defaultRedactor = (data) => redactValue(data, false);
+var MemorySink = class {
+  traces = /* @__PURE__ */ new Map();
+  async append(event) {
+    const events = this.traces.get(event.traceId) ?? [];
+    events.push(event);
+    this.traces.set(event.traceId, events);
+  }
+  async load(traceId) {
+    return [...this.traces.get(traceId) ?? []];
+  }
+  async list() {
+    return [...this.traces.keys()];
+  }
+};
+var JsonlSink = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  file(traceId) {
+    return join(this.dir, `${traceId}.jsonl`);
+  }
+  async append(event) {
+    await mkdir(this.dir, { recursive: true });
+    await appendFile(this.file(event.traceId), `${JSON.stringify(event)}
+`, "utf8");
+  }
+  async load(traceId) {
+    try {
+      const raw = await readFile(this.file(traceId), "utf8");
+      return raw.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async list() {
+    try {
+      const entries = await readdir(this.dir);
+      return entries.filter((f) => f.endsWith(".jsonl")).map((f) => f.slice(0, -".jsonl".length));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+};
+var Tracer = class {
+  traceId;
+  sink;
+  redactor;
+  now;
+  seq = 0;
+  events = [];
+  constructor(options) {
+    this.traceId = options.traceId;
+    this.sink = options.sink;
+    this.redactor = options.redactor;
+    this.now = options.now;
+  }
+  async event(kind, label, data, durationMs) {
+    const event = {
+      traceId: this.traceId,
+      seq: this.seq++,
+      at: this.now().toISOString(),
+      kind,
+      label,
+      ...data ? { data: this.redactor(data) } : {},
+      ...durationMs !== void 0 ? { durationMs } : {}
+    };
+    this.events.push(event);
+    await this.sink.append(event);
+    return event;
+  }
+  start(label = "mission", data) {
+    return this.event("mission_start", label, data);
+  }
+  end(label = "mission", data) {
+    return this.event("mission_end", label, data);
+  }
+  decision(label, data) {
+    return this.event("decision", label, data);
+  }
+  plan(label, data) {
+    return this.event("plan", label, data);
+  }
+  toolCall(label, data) {
+    return this.event("tool_call", label, data);
+  }
+  approval(label, data) {
+    return this.event("approval", label, data);
+  }
+  apply(label, data) {
+    return this.event("apply", label, data);
+  }
+  verify(label, data) {
+    return this.event("verify", label, data);
+  }
+  memory(label, data) {
+    return this.event("memory", label, data);
+  }
+  error(label, data) {
+    return this.event("error", label, data);
+  }
+  /** Start a timed span; call `.end()` to record it with a `durationMs`. */
+  span(kind, label, data) {
+    const startedAt = this.now().getTime();
+    return {
+      end: (extra) => {
+        const durationMs = this.now().getTime() - startedAt;
+        return this.event(kind, label, { ...data ?? {}, ...extra ?? {} }, durationMs);
+      }
+    };
+  }
+  /** In-memory view of this trace so far. */
+  snapshot() {
+    return buildTrace(this.traceId, this.events);
+  }
+};
+var Observability = class {
+  sink;
+  redactor;
+  now;
+  constructor(options = {}) {
+    this.sink = options.sink ?? (options.dir ? new JsonlSink(options.dir) : new MemorySink());
+    this.redactor = options.redactor ?? defaultRedactor;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  startTrace() {
+    return new Tracer({
+      traceId: randomUUID(),
+      sink: this.sink,
+      redactor: this.redactor,
+      now: this.now
+    });
+  }
+  async replay(traceId) {
+    return buildTrace(traceId, await this.sink.load(traceId));
+  }
+  async list() {
+    return this.sink.list();
+  }
+};
+function buildTrace(id, events) {
+  const sorted = [...events].sort((a, b) => a.seq - b.seq);
+  const startedAt = sorted[0]?.at;
+  const endEvent = [...sorted].reverse().find((e) => e.kind === "mission_end");
+  const endedAt = endEvent?.at ?? sorted[sorted.length - 1]?.at;
+  return {
+    id,
+    ...startedAt ? { startedAt } : {},
+    ...endedAt ? { endedAt } : {},
+    events: sorted
+  };
+}
+var autoApprove = () => ({ approved: true });
+var denyAll = () => ({
+  approved: false,
+  note: "no approver configured"
+});
+function cliApprover() {
+  return async (req) => {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      const answer = await rl.question(
+        `
+[origin] ${req.reason}
+  \u2192 ${req.action.summary}
+  Approve? [y/N] `
+      );
+      return { approved: /^y(es)?$/i.test(answer.trim()) };
+    } finally {
+      rl.close();
+    }
+  };
+}
+async function authorize(policy, action, approver, ctx) {
+  const gate = policy.gate(action, ctx);
+  if (gate === "allow") return { allowed: true, gate, via: "policy" };
+  if (gate === "deny") return { allowed: false, gate, via: "policy", note: "denied by policy" };
+  const decision = await approver({
+    action,
+    policy: policy.name,
+    reason: `${policy.name} requires approval for a ${action.kind} action`
+  });
+  return {
+    allowed: decision.approved,
+    gate,
+    via: "approver",
+    ...decision.note ? { note: decision.note } : {}
+  };
+}
+var READ_ONLY = /* @__PURE__ */ new Set(["read", "plan", "memory"]);
+var DEFAULT_BUDGET = { maxSteps: 25, maxToolCalls: 50 };
+function resolveBudget(budget) {
+  return { ...DEFAULT_BUDGET, ...budget ?? {} };
+}
+function isReadOnly(action) {
+  return READ_ONLY.has(action.kind) && !action.mutating;
+}
+function outsideRoot(target, root) {
+  if (!target || !root) return false;
+  const rel = relative(resolve(root), resolve(root, target));
+  return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+}
+function humanDirected(options = {}) {
+  return {
+    name: "humanDirected",
+    mode: "review",
+    budget: resolveBudget(options.budget),
+    gate(action) {
+      return isReadOnly(action) ? "allow" : "ask";
+    }
+  };
+}
+function reviewOnly(options = {}) {
+  return {
+    name: "reviewOnly",
+    mode: "plan",
+    budget: resolveBudget(options.budget),
+    gate(action) {
+      return isReadOnly(action) ? "allow" : "deny";
+    }
+  };
+}
+function autonomous(options = {}) {
+  const fullAuto = options.fullAuto ?? false;
+  return {
+    name: fullAuto ? "autonomous(full-auto)" : "autonomous",
+    mode: fullAuto ? "full-auto" : "auto",
+    budget: resolveBudget(options.budget),
+    gate(action, ctx) {
+      if (fullAuto) return "allow";
+      return outsideRoot(action.target, ctx?.root) ? "ask" : "allow";
+    }
+  };
+}
+var pexec = promisify(exec);
+var contractSchema = z.object({
+  commands: z.array(z.object({ cmd: z.string().min(1), expectExit: z.number().int().default(0) })).default([]),
+  http: z.array(z.object({ url: z.string().url(), expectStatus: z.number().int().default(200) })).default([]),
+  regex: z.array(z.object({ cmd: z.string().min(1), pattern: z.string().min(1) })).default([]),
+  criteria: z.array(z.string()).default([])
+});
+var defaultExec = async (cmd, opts) => {
+  try {
+    const { stdout: stdout2, stderr } = await pexec(cmd, {
+      cwd: opts.cwd,
+      timeout: opts.timeoutMs,
+      windowsHide: true
+    });
+    return { code: 0, stdout: String(stdout2), stderr: String(stderr) };
+  } catch (e) {
+    const err = e;
+    return {
+      code: typeof err.code === "number" ? err.code : 1,
+      stdout: err.stdout ?? "",
+      stderr: err.stderr ?? ""
+    };
+  }
+};
+async function evaluateContract(input, options = {}) {
+  const contract = contractSchema.parse(input);
+  const run = options.execImpl ?? defaultExec;
+  const doFetch = options.fetchImpl ?? fetch;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const checks = [];
+  for (const c of contract.commands) {
+    const res = await run(c.cmd, { cwd: options.cwd, timeoutMs });
+    checks.push({
+      type: "command",
+      target: c.cmd,
+      pass: res.code === c.expectExit,
+      detail: `exit ${res.code} (expected ${c.expectExit})`
+    });
+  }
+  for (const r of contract.regex) {
+    const res = await run(r.cmd, { cwd: options.cwd, timeoutMs });
+    let pass = false;
+    let detail;
+    try {
+      pass = new RegExp(r.pattern).test(`${res.stdout}
+${res.stderr}`);
+    } catch {
+      detail = "invalid pattern";
+    }
+    checks.push({ type: "regex", target: `${r.cmd} =~ /${r.pattern}/`, pass, ...detail ? { detail } : {} });
+  }
+  for (const h of contract.http) {
+    try {
+      const res = await doFetch(h.url, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
+      checks.push({
+        type: "http",
+        target: h.url,
+        pass: res.status === h.expectStatus,
+        detail: `status ${res.status} (expected ${h.expectStatus})`
+      });
+    } catch (e) {
+      checks.push({ type: "http", target: h.url, pass: false, detail: String(e) });
+    }
+  }
+  return certify(checks, contract.criteria, now().toISOString());
+}
+function certify(checks, criteria, issuedAt) {
+  const ok = checks.every((c) => c.pass);
+  const canonical = JSON.stringify({
+    checks: [...checks].sort((a, b) => `${a.type}:${a.target}`.localeCompare(`${b.type}:${b.target}`)),
+    criteria,
+    ok
+  });
+  const hash = createHash("sha256").update(canonical).digest("hex");
+  return { ok, checks, criteria, issuedAt, hash };
+}
+function parseContractFromPlan(plan) {
+  const block = plan.match(/```contract\s*([\s\S]*?)```/i)?.[1] ?? plan.match(/##\s*contract\s*([\s\S]*?)(?:\n#{1,3}\s|\n\n\n|$)/i)?.[1];
+  if (!block) return null;
+  const trimmed = block.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    return contractSchema.parse(JSON.parse(trimmed));
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/providers.ts
+var SUPPORTED_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "google",
+  "groq",
+  "mistral",
+  "openrouter"
+];
+var PROVIDER_KEY_ENV = {
+  anthropic: ["ANTHROPIC_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  google: ["GOOGLE_AI_API_KEY", "GEMINI_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"]
+};
+function isSupportedProvider(value) {
+  return SUPPORTED_PROVIDERS.includes(value);
+}
+function resolveProviderKey(provider, env = process.env) {
+  for (const name of PROVIDER_KEY_ENV[provider]) {
+    const value = env[name];
+    if (value) return value;
+  }
+  return null;
+}
+function availableProviders(env = process.env) {
+  return SUPPORTED_PROVIDERS.filter((p) => resolveProviderKey(p, env) !== null);
+}
+var ANTHROPIC_MAX_TOKENS = 4096;
+async function callProviderText(call) {
+  const res = await dispatch(call, false);
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Provider error (${call.provider} ${res.status}): ${body.slice(0, 500)}`);
+  }
+  return parseProviderText(call.provider, await res.json());
+}
+async function callProviderStream(call) {
+  return dispatch(call, true);
+}
+function dispatch(call, stream) {
+  const doFetch = call.fetchImpl ?? fetch;
+  switch (call.provider) {
+    case "anthropic":
+      return callAnthropic(call, stream, doFetch);
+    case "google":
+      return callGoogle(call, stream, doFetch);
+    case "openai":
+    case "groq":
+    case "mistral":
+    case "openrouter":
+      return callOpenAICompatible(call, stream, doFetch);
+    default: {
+      const exhaustive = call.provider;
+      return Promise.resolve(new Response(`Unsupported provider: ${String(exhaustive)}`, { status: 400 }));
+    }
+  }
+}
+function callAnthropic(call, stream, doFetch) {
+  const system = call.messages.find((m) => m.role === "system")?.content;
+  const messages = call.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role === "assistant" ? "assistant" : "user", content: m.content }));
+  return doFetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": call.apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model: call.model,
+      max_tokens: ANTHROPIC_MAX_TOKENS,
+      stream,
+      ...system ? { system } : {},
+      messages
+    }),
+    signal: call.signal
+  });
+}
+function callOpenAICompatible(call, stream, doFetch) {
+  const baseUrl = call.provider === "openai" ? "https://api.openai.com/v1" : call.provider === "groq" ? "https://api.groq.com/openai/v1" : call.provider === "openrouter" ? "https://openrouter.ai/api/v1" : "https://api.mistral.ai/v1";
+  return doFetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${call.apiKey}`,
+      "Content-Type": "application/json",
+      ...call.provider === "openrouter" ? { "HTTP-Referer": "https://archic.es", "X-Title": "Origin" } : {}
+    },
+    body: JSON.stringify({ model: call.model, messages: call.messages, stream }),
+    signal: call.signal
+  });
+}
+function callGoogle(call, stream, doFetch) {
+  const system = call.messages.find((m) => m.role === "system")?.content;
+  const contents = call.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role === "assistant" ? "model" : "user", parts: [{ text: m.content }] }));
+  const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  const separator = stream ? "&" : "?";
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(call.model)}:${method}${separator}key=${encodeURIComponent(call.apiKey)}`;
+  return doFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      contents,
+      ...system ? { systemInstruction: { parts: [{ text: system }] } } : {}
+    }),
+    signal: call.signal
+  });
+}
+function makeSSEParser(provider) {
+  return (line) => {
+    if (!line || line.startsWith(":") || !line.startsWith("data:")) return "";
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") return "";
+    try {
+      const obj = JSON.parse(payload);
+      if (provider === "anthropic") {
+        if (obj.type === "content_block_delta" && obj.delta?.type === "text_delta") {
+          return obj.delta.text ?? "";
+        }
+        return "";
+      }
+      if (provider === "google") {
+        const parts = obj.candidates?.[0]?.content?.parts;
+        if (Array.isArray(parts)) return parts.map((p) => p.text ?? "").join("");
+        return "";
+      }
+      return obj.choices?.[0]?.delta?.content ?? "";
+    } catch {
+      return "";
+    }
+  };
+}
+function parseProviderText(provider, body) {
+  const obj = body;
+  if (provider === "anthropic") {
+    return obj.content?.map((p) => p.text ?? "").join("").trim() ?? "";
+  }
+  if (provider === "google") {
+    return obj.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("").trim() ?? "";
+  }
+  return obj.choices?.[0]?.message?.content?.trim() ?? "";
+}
+var planResponseSchema = z.object({
+  rationale: z.string().optional(),
+  steps: z.array(
+    z.object({
+      description: z.string(),
+      tool: z.string().optional(),
+      input: z.unknown().optional(),
+      mutating: z.boolean().optional()
+    })
+  ).default([]),
+  contract: z.unknown().optional()
+});
+function extractJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1] ?? text;
+  const start = fenced.indexOf("{");
+  const end = fenced.lastIndexOf("}");
+  if (start === -1 || end === -1 || end < start) return {};
+  try {
+    return JSON.parse(fenced.slice(start, end + 1));
+  } catch {
+    return {};
+  }
+}
+function parsePlan(text, tools) {
+  const parsed = planResponseSchema.safeParse(extractJson(text));
+  if (!parsed.success) return { steps: [], rationale: "planner returned no actionable steps" };
+  const toolByName = new Map(tools.map((t) => [t.name, t]));
+  const steps = parsed.data.steps.map((step, i) => {
+    const tool = step.tool ? toolByName.get(step.tool) : void 0;
+    return {
+      id: `s${i + 1}`,
+      description: step.description,
+      ...tool ? { tool: tool.name } : {},
+      ...step.input !== void 0 ? { input: step.input } : {},
+      kind: tool ? tool.kind ?? "tool" : "plan",
+      mutating: step.mutating ?? tool?.mutating ?? false
+    };
+  });
+  return {
+    steps,
+    ...parsed.data.rationale ? { rationale: parsed.data.rationale } : {},
+    ...parsed.data.contract !== void 0 ? { contract: parsed.data.contract } : {}
+  };
+}
+
+// src/agent/reference-runtime.ts
+var DEFAULT_MODELS = {
+  openrouter: "openai/gpt-4o-mini",
+  openai: "gpt-4o-mini",
+  anthropic: "claude-3-5-sonnet-latest",
+  google: "gemini-1.5-flash",
+  groq: "llama-3.1-8b-instant",
+  mistral: "mistral-small-latest"
+};
+var ReferenceRuntime = class {
+  name = "reference";
+  complete;
+  constructor(options = {}) {
+    if (options.complete) {
+      this.complete = options.complete;
+      return;
+    }
+    const env = options.env ?? process.env;
+    const provider = options.provider ?? availableProviders(env)[0];
+    if (!provider) return;
+    const apiKey = resolveProviderKey(provider, env);
+    if (!apiKey) return;
+    const model = options.model ?? DEFAULT_MODELS[provider];
+    const fetchImpl = options.fetchImpl;
+    this.complete = (messages) => callProviderText({ provider, model, apiKey, messages, ...fetchImpl ? { fetchImpl } : {} });
+  }
+  async plan(ctx) {
+    if (!this.complete) return { steps: [], rationale: "dry-run: no LLM provider configured" };
+    const text = await this.complete([
+      { role: "system", content: buildPlannerSystem(ctx) },
+      { role: "user", content: `Goal: ${ctx.goal}
+
+Return the JSON plan now.` }
+    ]);
+    return parsePlan(text, ctx.tools);
+  }
+  async synthesize(ctx, observations) {
+    if (!this.complete) {
+      return `Origin dry-run for "${ctx.goal}". No LLM provider configured; recorded ${observations.length} step(s). Set a provider key (e.g. OPENROUTER_API_KEY) to enable reasoning.`;
+    }
+    const obs = observations.map(
+      (o) => `- ${o.stepId}: ${o.ok ? "ok" : "failed"}` + (o.output !== void 0 ? ` \u2192 ${truncate(JSON.stringify(o.output), 300)}` : "") + (o.error ? ` (error: ${o.error})` : "")
+    ).join("\n") || "(none)";
+    return this.complete([
+      {
+        role: "system",
+        content: "You are Origin. Using the goal, memory, and step results, write a concise, direct final answer for the user. No preamble."
+      },
+      {
+        role: "user",
+        content: `Goal: ${ctx.goal}
+
+Memory:
+${ctx.memoryBlock || "(none)"}
+
+Step results:
+${obs}
+
+Final answer:`
+      }
+    ]);
+  }
+};
+function buildPlannerSystem(ctx) {
+  const tools = ctx.tools.length ? ctx.tools.map((t) => `- ${t.name}: ${t.description ?? "(no description)"}${t.mutating ? " [mutating]" : ""}`).join("\n") : "(no tools available)";
+  return [
+    "You are Origin's planner. Decompose the user's goal into a short ordered list of steps (1-5).",
+    'Use a tool only when an action is required; otherwise omit "tool".',
+    "Available tools:",
+    tools,
+    'Respond ONLY with JSON: {"rationale": string, "steps": [{"description": string, "tool"?: string, "input"?: any, "mutating"?: boolean}], "contract"?: {"commands"?: [{"cmd": string}], "criteria"?: [string]}}.'
+  ].join("\n");
+}
+function truncate(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
+// src/agent/agent.ts
+var ApolloAgent = class {
+  memory;
+  observability;
+  tools;
+  policy;
+  contextEngine;
+  approver;
+  runtime;
+  root;
+  constructor(options = {}) {
+    this.memory = options.memory ?? new Memory();
+    this.tools = options.tools ?? [];
+    this.policy = options.policy ?? humanDirected();
+    this.contextEngine = options.context ?? new ContextEngine();
+    this.observability = options.observability ?? new Observability();
+    this.approver = options.approver ?? (this.policy.mode === "auto" || this.policy.mode === "full-auto" ? autoApprove : cliApprover());
+    this.runtime = options.runtime ?? new ReferenceRuntime({
+      ...options.complete ? { complete: options.complete } : {},
+      ...options.provider ? { provider: options.provider } : {},
+      ...options.model ? { model: options.model } : {}
+    });
+    this.root = options.root ?? process.cwd();
+  }
+  async run(goal) {
+    const { runtime, memory, contextEngine, observability, policy, approver, tools, root } = this;
+    const tracer = observability.startTrace();
+    await tracer.start(goal, { policy: policy.name, mode: policy.mode });
+    const context = await contextEngine.scan({
+      root,
+      goal,
+      tools: tools.map((t) => ({ name: t.name, ...t.description ? { description: t.description } : {} }))
+    });
+    await tracer.decision("context scanned", {
+      files: context.files.length,
+      languages: context.languages
+    });
+    const memoryBlock = await memory.formatBlock(goal);
+    if (memoryBlock) await tracer.memory("recalled memory");
+    const rctx = { goal, context, memoryBlock, tools };
+    const plan = await runtime.plan(rctx);
+    await tracer.plan(`planned ${plan.steps.length} step(s)`, {
+      ...plan.rationale ? { rationale: plan.rationale } : {},
+      steps: plan.steps.map((s) => s.description)
+    });
+    const observations = [];
+    for (const step of plan.steps) {
+      if (observations.length >= policy.budget.maxSteps) {
+        await tracer.decision("step budget reached", { maxSteps: policy.budget.maxSteps });
+        break;
+      }
+      const action = {
+        kind: step.kind,
+        summary: step.description,
+        ...step.tool ? { tool: step.tool } : {},
+        mutating: step.mutating
+      };
+      const auth = await authorize(policy, action, approver, { root });
+      await tracer.approval(`${auth.gate}: ${auth.allowed ? "allowed" : "blocked"}`, {
+        step: step.description,
+        via: auth.via,
+        ...auth.note ? { note: auth.note } : {}
+      });
+      if (!auth.allowed) {
+        observations.push({
+          stepId: step.id,
+          ok: false,
+          skipped: true,
+          error: auth.note ?? "blocked by policy"
+        });
+        continue;
+      }
+      if (!step.tool) {
+        observations.push({ stepId: step.id, ok: true, output: step.description });
+        continue;
+      }
+      const tool = tools.find((t) => t.name === step.tool);
+      if (!tool) {
+        await tracer.error("unknown tool", { tool: step.tool });
+        observations.push({ stepId: step.id, ok: false, error: `unknown tool: ${step.tool}` });
+        continue;
+      }
+      const span = tracer.span("tool_call", tool.name, { input: step.input });
+      try {
+        const output = await tool.run(step.input, { goal });
+        observations.push({ stepId: step.id, ok: true, output });
+        await span.end({ ok: true });
+      } catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        observations.push({ stepId: step.id, ok: false, error });
+        await span.end({ ok: false, error });
+      }
+    }
+    const answer = await runtime.synthesize(rctx, observations);
+    let certificate;
+    if (plan.contract !== void 0 && policy.mode !== "plan") {
+      const auth = await authorize(
+        policy,
+        { kind: "exec", summary: "verify success contract", mutating: false },
+        approver,
+        { root }
+      );
+      if (auth.allowed) {
+        certificate = await evaluateContract(plan.contract, { cwd: root });
+        await tracer.verify(certificate.ok ? "contract passed" : "contract failed", {
+          ok: certificate.ok,
+          hash: certificate.hash
+        });
+      } else {
+        await tracer.decision("contract verification skipped", { reason: auth.note ?? "blocked" });
+      }
+    }
+    await memory.remember({
+      content: `Goal: ${goal}
+Answer: ${truncate2(answer, 1500)}`,
+      kind: "mission",
+      importance: 2,
+      source: "agent"
+    });
+    await tracer.memory("saved mission");
+    await tracer.end("completed", certificate ? { contractOk: certificate.ok } : void 0);
+    return {
+      goal,
+      answer,
+      steps: plan.steps,
+      observations,
+      ...certificate ? { certificate } : {},
+      traceId: tracer.traceId,
+      policy: policy.name
+    };
+  }
+};
+function truncate2(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
+// src/agent/runtime.ts
+function defineTool(spec) {
+  return spec;
+}
+
+export { ApolloAgent, ContextEngine, Ignore, InMemoryStore, JsonlSink, Memory, MemorySink, Observability, PROVIDER_KEY_ENV, ReferenceRuntime, SUPPORTED_PROVIDERS, Tracer, authorize, autoApprove, autonomous, availableProviders, callProviderStream, callProviderText, cliApprover, contractSchema, defaultRedactor, defineTool, denyAll, evaluateContract, formatMemoriesBlock, humanDirected, isSupportedProvider, makeSSEParser, outsideRoot, parseContractFromPlan, parseIgnore, parseIntent, parsePlan, resolveProviderKey, reviewOnly, tokenize };
+//# sourceMappingURL=chunk-77G3SI57.js.map
+//# sourceMappingURL=chunk-77G3SI57.js.map