@tekmidian/pai 0.36.2 → 0.38.0

package/dist/hooks/worker-status-line.mjs

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+
+// src/workers/config.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/config/json-store.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  renameSync,
+  unlinkSync,
+  mkdirSync
+} from "node:fs";
+function readJsonStrict(path, label = path) {
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (e) {
+    throw new Error(
+      `Could not read ${label}: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 writing now would replace its contents with ours alone.`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 overwriting it would destroy whatever it holds.
+Repair the file, or move it aside and re-run this command.`
+    );
+  }
+}
+
+// src/daemon/config.ts
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+
+// src/notifications/types.ts
+var DEFAULT_ROUTING = {
+  error: ["whatsapp", "macos", "ntfy", "cli"],
+  completion: ["whatsapp", "macos", "ntfy", "cli"],
+  info: ["cli"],
+  progress: ["cli"],
+  debug: []
+};
+var DEFAULT_CHANNELS = {
+  ntfy: {
+    enabled: false,
+    url: void 0,
+    priority: "default"
+  },
+  whatsapp: {
+    enabled: true,
+    recipient: void 0
+  },
+  macos: {
+    enabled: true
+  },
+  voice: {
+    enabled: false,
+    voiceName: "bm_george"
+  },
+  cli: {
+    enabled: true
+  }
+};
+var DEFAULT_NOTIFICATION_CONFIG = {
+  mode: "auto",
+  channels: DEFAULT_CHANNELS,
+  routing: DEFAULT_ROUTING
+};
+
+// src/tasks/types.ts
+var DEFAULT_TASK_CONFIG = {
+  enabled: false,
+  providers: {
+    todoist: {
+      enabled: false
+    }
+  },
+  autoDispatch: false
+};
+
+// src/runtime-paths.ts
+function paiSocketPath() {
+  return process.env.PAI_SOCKET_PATH ?? "/tmp/pai.sock";
+}
+
+// src/daemon/config.ts
+function perUserDbName() {
+  const username = userInfo().username;
+  const safe = username.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  return `pai_${safe}`;
+}
+function perUserConnectionString() {
+  const db = perUserDbName();
+  return `postgresql://pai:pai@localhost:5432/${db}`;
+}
+var DEFAULTS = {
+  socketPath: paiSocketPath(),
+  indexIntervalSecs: 300,
+  embedIntervalSecs: 600,
+  embedOnStartup: false,
+  storageBackend: "sqlite",
+  postgres: {
+    connectionString: perUserConnectionString(),
+    maxConnections: 5,
+    connectionTimeoutMs: 5e3
+  },
+  embeddingModel: "Snowflake/snowflake-arctic-embed-m-v1.5",
+  logLevel: "info",
+  notifications: DEFAULT_NOTIFICATION_CONFIG,
+  tasks: DEFAULT_TASK_CONFIG,
+  // Deliberately empty. An install must not guess who the user is: a wrong
+  // guess here is an address that can be mailed without review.
+  identity: { selfEmails: [] },
+  search: {
+    mode: "keyword",
+    rerank: true,
+    recencyBoostDays: 90,
+    defaultLimit: 10,
+    snippetLength: 200
+  }
+};
+var CONFIG_DIR = join(homedir(), ".config", "pai");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+// src/workers/config.ts
+var PROVIDER_TAGS = [
+  "code",
+  "vision",
+  "image-gen",
+  "long-context",
+  "fast",
+  "reasoning"
+];
+var DEFAULT_LOG_DIR = "~/.claude/logs/workers";
+var DEFAULT_PANE = {
+  enabled: true,
+  fontSize: 13,
+  autoExitSecs: 60
+};
+var DEFAULT_ROUTING2 = {
+  order: [],
+  cooldownMinutes: 30,
+  retryOnQuota: true
+};
+function defaultWorkersConfig() {
+  return {
+    enabled: false,
+    active: null,
+    providers: {},
+    classes: {},
+    mcpSets: {},
+    pane: { ...DEFAULT_PANE },
+    logDir: DEFAULT_LOG_DIR,
+    routing: { ...DEFAULT_ROUTING2, order: [] }
+  };
+}
+var WorkersConfigError = class extends Error {
+};
+function bad(path, why) {
+  throw new WorkersConfigError(`workers${path}: ${why}`);
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function parseProvider(name, raw) {
+  if (typeof raw !== "object" || raw === null) bad(`.providers.${name}`, "must be an object");
+  const p = raw;
+  const protocol = p.protocol === void 0 ? "anthropic" : str(p.protocol);
+  if (protocol !== "anthropic" && protocol !== "openai") {
+    bad(`.providers.${name}.protocol`, `"${str(p.protocol)}" is neither "anthropic" nor "openai"`);
+  }
+  const engine = p.engine === void 0 ? "claude" : str(p.engine);
+  if (engine !== "claude" && engine !== "codex") {
+    bad(`.providers.${name}.engine`, `"${str(p.engine)}" is neither "claude" nor "codex"`);
+  }
+  const baseUrl = str(p.baseUrl);
+  if (!baseUrl && protocol !== "openai") bad(`.providers.${name}.baseUrl`, "is required");
+  const keyFile = p.keyFile === void 0 || p.keyFile === null || str(p.keyFile) === "" ? null : str(p.keyFile);
+  const modelsRaw = p.models === void 0 ? {} : p.models;
+  if (typeof modelsRaw !== "object" || modelsRaw === null) {
+    bad(`.providers.${name}.models`, "must be an object");
+  }
+  const m = modelsRaw;
+  const defaultModel = str(m.default);
+  if (!defaultModel) bad(`.providers.${name}.models.default`, "is required");
+  const fast = m.fast === void 0 ? void 0 : str(m.fast);
+  const env = {};
+  if (p.env !== void 0) {
+    if (typeof p.env !== "object" || p.env === null || Array.isArray(p.env)) {
+      bad(`.providers.${name}.env`, "must be an object of string values");
+    }
+    for (const [k, v] of Object.entries(p.env)) {
+      if (typeof v !== "string") bad(`.providers.${name}.env.${k}`, "must be a string");
+      env[k] = v;
+    }
+  }
+  const quotaSkipAt = p.quotaSkipAt === void 0 ? void 0 : p.quotaSkipAt;
+  if (quotaSkipAt !== void 0) {
+    if (typeof quotaSkipAt !== "number" || quotaSkipAt < 0 || quotaSkipAt > 100) {
+      bad(`.providers.${name}.quotaSkipAt`, "must be a number between 0 and 100");
+    }
+  }
+  const contextWindow = p.contextWindow === void 0 ? void 0 : p.contextWindow;
+  if (contextWindow !== void 0) {
+    if (typeof contextWindow !== "number" || contextWindow <= 0) {
+      bad(`.providers.${name}.contextWindow`, "must be a positive number of tokens");
+    }
+  }
+  const upstreamUrl = str(p.upstreamUrl);
+  if (protocol === "openai" && !upstreamUrl) {
+    bad(`.providers.${name}.upstreamUrl`, `is required for protocol "openai" (the Chat Completions base, e.g. "https://api.openai.com/v1")`);
+  }
+  const costTier = p.costTier === void 0 ? void 0 : p.costTier;
+  if (costTier !== void 0) {
+    if (typeof costTier !== "number" || !Number.isInteger(costTier) || costTier < 1 || costTier > 5) {
+      bad(`.providers.${name}.costTier`, "must be an integer 1 (cheapest) \u2026 5 (most expensive)");
+    }
+  }
+  let tags;
+  if (p.tags !== void 0) {
+    if (!Array.isArray(p.tags) || p.tags.some((x) => typeof x !== "string")) {
+      bad(`.providers.${name}.tags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+    }
+    for (const t of p.tags) {
+      if (!PROVIDER_TAGS.includes(t)) {
+        bad(`.providers.${name}.tags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+      }
+    }
+    tags = p.tags;
+  }
+  return {
+    enabled: p.enabled === void 0 ? true : p.enabled === true,
+    protocol,
+    baseUrl,
+    keyFile,
+    models: fast ? { default: defaultModel, fast } : { default: defaultModel },
+    env,
+    ...str(p.note) ? { note: str(p.note) } : {},
+    ...upstreamUrl ? { upstreamUrl } : {},
+    ...engine !== "claude" ? { engine } : {},
+    ...str(p.quotaProbe) ? { quotaProbe: str(p.quotaProbe) } : {},
+    ...quotaSkipAt !== void 0 ? { quotaSkipAt } : {},
+    ...contextWindow !== void 0 ? { contextWindow } : {},
+    ...costTier !== void 0 ? { costTier } : {},
+    ...tags ? { tags } : {}
+  };
+}
+function parseWorkersConfig(raw) {
+  const d = defaultWorkersConfig();
+  if (raw === void 0 || raw === null) return d;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    bad("", "section must be an object");
+  }
+  const w = raw;
+  const providers = {};
+  if (w.providers !== void 0) {
+    if (typeof w.providers !== "object" || w.providers === null || Array.isArray(w.providers)) {
+      bad(".providers", "must be an object keyed by provider name");
+    }
+    for (const [name, p] of Object.entries(w.providers)) {
+      providers[name] = parseProvider(name, p);
+    }
+  }
+  const classes = {};
+  const classesRaw = w.classes !== void 0 ? w.classes : w.roles;
+  if (classesRaw !== void 0) {
+    if (typeof classesRaw !== "object" || classesRaw === null || Array.isArray(classesRaw)) {
+      bad(w.classes !== void 0 ? ".classes" : ".roles", "must be an object of class \u2192 provider[/alias] or {provider, mcp, maxCostTier, requireTags, order}");
+    }
+    for (const [cls, target] of Object.entries(classesRaw)) {
+      if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+        const o = target;
+        const provider = str(o.provider);
+        if (o.provider !== void 0 && (!provider || provider.includes(" "))) {
+          bad(`.classes.${cls}.provider`, `invalid provider "${provider}"`);
+        }
+        let mcp;
+        if (o.mcp !== void 0) {
+          if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.mcp`, "must be an array of MCP server or set names");
+          }
+          mcp = o.mcp;
+        }
+        let maxCostTier;
+        if (o.maxCostTier !== void 0) {
+          if (typeof o.maxCostTier !== "number" || !Number.isInteger(o.maxCostTier) || o.maxCostTier < 1 || o.maxCostTier > 5) {
+            bad(`.classes.${cls}.maxCostTier`, "must be an integer 1 \u2026 5");
+          }
+          maxCostTier = o.maxCostTier;
+        }
+        let requireTags;
+        if (o.requireTags !== void 0) {
+          if (!Array.isArray(o.requireTags) || o.requireTags.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.requireTags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+          }
+          for (const t of o.requireTags) {
+            if (!PROVIDER_TAGS.includes(t)) {
+              bad(`.classes.${cls}.requireTags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+            }
+          }
+          requireTags = o.requireTags;
+        }
+        let order;
+        if (o.order !== void 0) {
+          if (!Array.isArray(o.order) || o.order.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.order`, "must be an array of provider names");
+          }
+          order = o.order;
+        }
+        const obj = {
+          ...provider ? { provider } : {},
+          ...mcp ? { mcp } : {},
+          ...maxCostTier !== void 0 ? { maxCostTier } : {},
+          ...requireTags ? { requireTags } : {},
+          ...order ? { order } : {}
+        };
+        classes[cls] = Object.keys(obj).length ? obj : {};
+      } else {
+        const t = str(target);
+        if (!t || t.includes(" ")) bad(`.classes.${cls}`, `invalid target "${t}"`);
+        classes[cls] = t;
+      }
+    }
+  }
+  const mcpSets = {};
+  if (w.mcpSets !== void 0) {
+    if (typeof w.mcpSets !== "object" || w.mcpSets === null || Array.isArray(w.mcpSets)) {
+      bad(".mcpSets", "must be an object of set name \u2192 [server names]");
+    }
+    for (const [setName, servers] of Object.entries(w.mcpSets)) {
+      if (!Array.isArray(servers) || servers.some((x) => typeof x !== "string")) {
+        bad(`.mcpSets.${setName}`, "must be an array of MCP server names");
+      }
+      mcpSets[setName] = servers;
+    }
+  }
+  let pane = { ...DEFAULT_PANE };
+  if (w.pane !== void 0) {
+    if (typeof w.pane !== "object" || w.pane === null) bad(".pane", "must be an object");
+    const pc = w.pane;
+    if (pc.enabled !== void 0 && typeof pc.enabled !== "boolean") bad(".pane.enabled", "must be boolean");
+    if (pc.fontSize !== void 0 && (typeof pc.fontSize !== "number" || pc.fontSize <= 0)) {
+      bad(".pane.fontSize", "must be a positive number of points");
+    }
+    if (pc.autoExitSecs !== void 0 && typeof pc.autoExitSecs !== "number") {
+      bad(".pane.autoExitSecs", "must be a number");
+    }
+    pane = {
+      enabled: pc.enabled === void 0 ? DEFAULT_PANE.enabled : pc.enabled === true,
+      fontSize: pc.fontSize === void 0 ? DEFAULT_PANE.fontSize : pc.fontSize,
+      autoExitSecs: pc.autoExitSecs === void 0 ? DEFAULT_PANE.autoExitSecs : pc.autoExitSecs
+    };
+  }
+  let routing = { ...DEFAULT_ROUTING2, order: [] };
+  if (w.routing !== void 0) {
+    if (typeof w.routing !== "object" || w.routing === null) bad(".routing", "must be an object");
+    const r = w.routing;
+    if (r.order !== void 0) {
+      if (!Array.isArray(r.order) || r.order.some((x) => typeof x !== "string")) {
+        bad(".routing.order", "must be an array of provider names");
+      }
+      routing.order = r.order;
+    }
+    if (r.cooldownMinutes !== void 0 && typeof r.cooldownMinutes !== "number") {
+      bad(".routing.cooldownMinutes", "must be a number");
+    }
+    if (r.retryOnQuota !== void 0 && typeof r.retryOnQuota !== "boolean") {
+      bad(".routing.retryOnQuota", "must be boolean");
+    }
+    routing = {
+      order: routing.order,
+      cooldownMinutes: r.cooldownMinutes === void 0 ? DEFAULT_ROUTING2.cooldownMinutes : r.cooldownMinutes,
+      retryOnQuota: r.retryOnQuota === void 0 ? DEFAULT_ROUTING2.retryOnQuota : r.retryOnQuota === true
+    };
+  }
+  const active = w.active === void 0 || w.active === null ? null : str(w.active);
+  if (active !== null && active !== "auto" && !(active in providers)) {
+  }
+  return {
+    enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
+    active,
+    providers,
+    classes,
+    mcpSets,
+    pane,
+    logDir: str(w.logDir) || d.logDir,
+    routing
+  };
+}
+function readWorkersSection() {
+  const raw = readJsonStrict(CONFIG_FILE, "~/.config/pai/config.json");
+  return { raw, workers: parseWorkersConfig(raw.workers) };
+}
+function expandHome(p) {
+  if (p === "~" || p.startsWith("~/")) return join2(homedir2(), p.slice(1));
+  return p;
+}
+
+// src/workers/paths.ts
+function workersLogDir(config) {
+  return expandHome(config.logDir);
+}
+
+// src/workers/status.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2, readdirSync } from "node:fs";
+import { join as join3 } from "node:path";
+function contextPercent(s) {
+  if (!s.contextTokens || !s.contextWindow) return null;
+  return Math.round(s.contextTokens / s.contextWindow * 100);
+}
+function loadStatuses(logDir) {
+  if (!existsSync2(logDir)) return [];
+  const out = [];
+  for (const name of readdirSync(logDir).sort()) {
+    if (!name.endsWith(".status")) continue;
+    try {
+      out.push(JSON.parse(readFileSync2(join3(logDir, name), "utf8")));
+    } catch {
+    }
+  }
+  return out;
+}
+function alive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ageOf(ts, now = /* @__PURE__ */ new Date()) {
+  const t = Date.parse(ts.replace(" ", "T"));
+  if (Number.isNaN(t)) return "?";
+  const s = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
+  return s < 90 ? `${s}s` : `${Math.floor(s / 60)}m`;
+}
+
+// src/workers/scope.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+var AIBROKER_REGISTRY = join4(homedir3(), ".aibroker", "session-names.json");
+function tabKey(term2) {
+  if (!term2) return "";
+  const head = term2.split("p", 1)[0];
+  const parts = head.slice(1).split("t");
+  if (head.startsWith("w") && parts.length === 2 && parts.every((p) => /^\d+$/.test(p))) {
+    return head;
+  }
+  return "";
+}
+function itermUuid(term2) {
+  if (!term2) return "";
+  return term2.split(":").pop() ?? "";
+}
+function workerInScope(worker, term2) {
+  if (!term2) return false;
+  const uuid = itermUuid(term2);
+  if (worker.session?.id && uuid) return worker.session.id === uuid;
+  return tabKey(worker.term) === tabKey(term2) && tabKey(term2) !== "";
+}
+
+// src/workers/report.ts
+var WORKER_CONTRACT_PROMPT = [
+  "You are a headless implementation worker, run non-interactively by an orchestrating session.",
+  "No narration, no timestamps, no greetings, no summaries of what you read; act, verify, then stop.",
+  "Your ONE final message is a JSON object and nothing else \u2014 no prose before or after, no code fence:",
+  '{"changed":[{"path":"\u2026","summary":"\u2026"}],"commands":["\u2026"],"checks":[{"name":"\u2026","ok":true,"detail":"\u2026"}],"open":["\u2026"],"notes":"one line"}',
+  "changed: files you touched (path + one-line summary). commands: the commands that verify the work.",
+  "checks: each with ok true/false and the evidence in detail. open: what you could not finish, if anything.",
+  "notes: one line, the headline a reviewer reads first."
+].join("\n");
+
+// src/workers/render.ts
+var CODES = {
+  dim: "2",
+  bold: "1",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  mag: "35",
+  cyan: "36"
+};
+function makeColor(enabled) {
+  return (name, s) => enabled ? `\x1B[${CODES[name]}m${s}\x1B[0m` : s;
+}
+function fmtK(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function contextMeter(c, s, minPct = 0) {
+  const pct = contextPercent(s);
+  if (pct === null || pct <= minPct) return null;
+  const label = `ctx ${fmtK(s.contextTokens ?? 0)}/${fmtK(s.contextWindow ?? 0)} (${pct}%)`;
+  if (pct > 85) return c("red", label);
+  if (pct > 70) return c("yellow", label);
+  return label;
+}
+function renderStatusLine(mine, now = /* @__PURE__ */ new Date(), c = makeColor(true)) {
+  if (!mine.length) return "";
+  const running = mine.filter((s) => s.state === "running" && alive(s.pid));
+  const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const doneToday = mine.filter((s) => s.state !== "running" && s.started.startsWith(today));
+  const ok = doneToday.filter((s) => s.state === "done").length;
+  const bad2 = doneToday.length - ok;
+  const providers = new Set(running.map((s) => s.provider));
+  const providerTag = providers.size === 1 ? [...providers][0] : "workers";
+  let head = `${providerTag} \u25B6${running.length}`;
+  const parts = running.slice(0, 3).map((s) => {
+    const meter = contextMeter(c, s, 60);
+    return `${s.id.slice(-4)} ${s.label.slice(0, 26)} ${ageOf(s.started, now)} \xB7 ${s.last.slice(0, 30)}` + (meter ? ` ${meter}` : "");
+  });
+  if (parts.length) head += "  " + parts.join(" | ");
+  if (doneToday.length) head += `   \u2713${ok} \u2717${bad2} today`;
+  return head;
+}
+
+// src/workers/viewer.ts
+function statusLineOutput(logDir, term2, cwd2, now = /* @__PURE__ */ new Date()) {
+  const statuses = loadStatuses(logDir);
+  const mine = statuses.filter((s) => {
+    const sameScope = term2 && workerInScope(s, term2);
+    const sameDir = cwd2 && s.cwd.startsWith(cwd2);
+    return sameScope || !term2 && sameDir;
+  });
+  return renderStatusLine(mine, now);
+}
+
+// src/workers/standalone/status-line.ts
+var term = process.argv[2] ?? process.env.ITERM_SESSION_ID ?? "";
+var cwd = process.argv[3] ?? process.cwd();
+try {
+  const out = statusLineOutput(workersLogDir(readWorkersSection().workers), term, cwd);
+  if (out) process.stdout.write(out + "\n");
+} catch {
+}
+//# sourceMappingURL=worker-status-line.mjs.map