rigjs 3.0.32 → 4.0.2

package/lib/wiki/agent/codex.ts

@@ -0,0 +1,22 @@
+import { spawnSync } from 'child_process';
+import { AgentAdapter, AgentDetect, AgentRunOpts, AgentRunResult, NotImplementedError } from './types';
+
+/**
+ * Stub. Detection works; `run` will throw until the permission/whitelist API
+ * of the codex CLI is settled. Target P3.
+ */
+export class CodexAdapter implements AgentAdapter {
+  name = 'codex' as const;
+
+  async detect(): Promise<AgentDetect> {
+    const which = spawnSync('command', ['-v', 'codex'], { encoding: 'utf8', shell: '/bin/sh' });
+    const binPath = (which.stdout || '').trim();
+    if (which.status !== 0 || !binPath) return { installed: false };
+    const v = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+    return { installed: true, path: binPath, version: (v.stdout || '').trim() || undefined };
+  }
+
+  async run(_opts: AgentRunOpts): Promise<AgentRunResult> {
+    throw new NotImplementedError('codex');
+  }
+}

package/lib/wiki/agent/index.ts

@@ -0,0 +1,11 @@
+import agentList from './list';
+import agentUse from './use';
+
+export { adapters, getAdapter } from './registry';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerAgentCommands(parent: any): void {
+  const agent = parent.command('agent').description('inspect / configure agent CLIs');
+  agent.command('list').description('list installed agent CLIs').action(agentList);
+  agent.command('use <name>').description('set default agent (claude|codex|pi)').action(agentUse);
+}

package/lib/wiki/agent/list.ts

@@ -0,0 +1,27 @@
+import print from '../../print';
+import { adapters } from './registry';
+import { loadRigConfig } from '../config';
+
+export default async function agentList(): Promise<void> {
+  const defaultAgent = loadRigConfig().wiki?.defaultAgent || 'claude';
+  print.info('rig wiki — agent adapters');
+  for (const a of adapters) {
+    let row: string;
+    try {
+      const d = await a.detect();
+      row = d.installed
+        ? `  ${star(a.name, defaultAgent)} ${a.name.padEnd(7)} installed  ${d.version || '(no --version output)'}  ${d.path || ''}`
+        : `  ${star(a.name, defaultAgent)} ${a.name.padEnd(7)} not installed`;
+    } catch (e: any) {
+      row = `  ${star(a.name, defaultAgent)} ${a.name.padEnd(7)} ERROR  ${e.message}`;
+    }
+    // eslint-disable-next-line no-console
+    console.log(row);
+  }
+  // eslint-disable-next-line no-console
+  console.log(`\ndefault: ${defaultAgent}   (change with: rig wiki agent use <name>)`);
+}
+
+function star(name: string, def: string) {
+  return name === def ? '*' : ' ';
+}

package/lib/wiki/agent/pi.ts

@@ -0,0 +1,21 @@
+import { spawnSync } from 'child_process';
+import { AgentAdapter, AgentDetect, AgentRunOpts, AgentRunResult, NotImplementedError } from './types';
+
+/**
+ * Stub. Target P3. Upstream CLI not yet fixed (Bo to specify which `pi`).
+ */
+export class PiAdapter implements AgentAdapter {
+  name = 'pi' as const;
+
+  async detect(): Promise<AgentDetect> {
+    const which = spawnSync('command', ['-v', 'pi'], { encoding: 'utf8', shell: '/bin/sh' });
+    const binPath = (which.stdout || '').trim();
+    if (which.status !== 0 || !binPath) return { installed: false };
+    const v = spawnSync('pi', ['--version'], { encoding: 'utf8' });
+    return { installed: true, path: binPath, version: (v.stdout || '').trim() || undefined };
+  }
+
+  async run(_opts: AgentRunOpts): Promise<AgentRunResult> {
+    throw new NotImplementedError('pi');
+  }
+}

package/lib/wiki/agent/registry.ts

@@ -0,0 +1,16 @@
+import { AgentAdapter, AgentName } from './types';
+import { ClaudeAdapter } from './claude';
+import { CodexAdapter } from './codex';
+import { PiAdapter } from './pi';
+
+export const adapters: AgentAdapter[] = [
+  new ClaudeAdapter(),
+  new CodexAdapter(),
+  new PiAdapter(),
+];
+
+export function getAdapter(name: AgentName): AgentAdapter {
+  const a = adapters.find(x => x.name === name);
+  if (!a) throw new Error(`unknown agent: ${name}`);
+  return a;
+}

package/lib/wiki/agent/types.ts

@@ -0,0 +1,37 @@
+export type AgentName = 'claude' | 'codex' | 'pi';
+
+export interface AgentDetect {
+  installed: boolean;
+  version?: string;
+  path?: string;
+}
+
+export interface AgentRunOpts {
+  prompt: string;
+  systemPrompt?: string;
+  files?: string[];
+  cwd: string;
+  allowWrite: boolean;
+  tools?: ('webfetch' | 'qmd' | 'bash')[];
+  timeoutMs?: number;
+}
+
+export interface AgentRunResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+  exitCode: number;
+}
+
+export interface AgentAdapter {
+  name: AgentName;
+  detect(): Promise<AgentDetect>;
+  run(opts: AgentRunOpts): Promise<AgentRunResult>;
+}
+
+export class NotImplementedError extends Error {
+  constructor(adapter: string) {
+    super(`adapter "${adapter}" is not implemented yet (P3 roadmap)`);
+  }
+}

package/lib/wiki/agent/use.ts

@@ -0,0 +1,21 @@
+import print from '../../print';
+import { loadRigConfig, saveRigConfig } from '../config';
+import { AgentName } from './types';
+
+const VALID: AgentName[] = ['claude', 'codex', 'pi'];
+const IMPLEMENTED: AgentName[] = ['claude'];
+
+export default function agentUse(name: string): void {
+  if (!VALID.includes(name as AgentName)) {
+    print.error(`unknown agent: ${name} (valid: ${VALID.join(', ')})`);
+    process.exit(1);
+  }
+  if (!IMPLEMENTED.includes(name as AgentName)) {
+    print.error(`adapter "${name}" is not implemented yet (P3 roadmap). Stick with "claude" for now.`);
+    process.exit(20);
+  }
+  const cfg = loadRigConfig();
+  cfg.wiki = { ...(cfg.wiki || {}), defaultAgent: name as AgentName };
+  saveRigConfig(cfg);
+  print.succeed(`default agent set to ${name}`);
+}

package/lib/wiki/config.ts

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import JSON5 from 'json5';
+import { paths } from './paths';
+
+export interface RigConfig {
+  wiki?: {
+    defaultAgent?: 'claude' | 'codex' | 'pi';
+    qmd?: { enabled?: 'auto' | 'on' | 'off' };
+    logRotateMB?: number;
+  };
+}
+
+export interface WikiEntry {
+  name: string;
+  path: string;            // absolute path to wiki dir
+  project?: string;        // absolute path to project root
+  include?: string[];
+  exclude?: string[];
+  schedule?: { scan?: string; lint?: string; ingest?: string | null };
+  ingestRules?: { match: string; mode: 'auto-on-new' | 'propose-only' }[];
+}
+
+export interface WikiConfig {
+  defaults?: {
+    schedule?: { scan?: string; lint?: string; ingest?: string | null };
+  };
+  wikis: WikiEntry[];
+}
+
+const DEFAULT_CONFIG: RigConfig = {
+  wiki: { defaultAgent: 'claude', qmd: { enabled: 'auto' }, logRotateMB: 50 },
+};
+
+const DEFAULT_WIKI_CONFIG: WikiConfig = {
+  defaults: { schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null } },
+  wikis: [],
+};
+
+function ensureHomeDir() {
+  fs.mkdirSync(paths.home, { recursive: true });
+  fs.mkdirSync(paths.locks, { recursive: true });
+  fs.mkdirSync(paths.logs, { recursive: true });
+  fs.mkdirSync(paths.cache, { recursive: true });
+}
+
+function readJson5<T>(file: string, fallback: T): T {
+  if (!fs.existsSync(file)) return fallback;
+  try {
+    return JSON5.parse(fs.readFileSync(file, 'utf8')) as T;
+  } catch (e: any) {
+    throw new Error(`failed to parse ${file}: ${e.message}`);
+  }
+}
+
+function writeJson5(file: string, data: unknown) {
+  fs.writeFileSync(file, JSON5.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+export function loadRigConfig(): RigConfig {
+  ensureHomeDir();
+  return { ...DEFAULT_CONFIG, ...readJson5<RigConfig>(paths.config, DEFAULT_CONFIG) };
+}
+
+export function saveRigConfig(cfg: RigConfig) {
+  ensureHomeDir();
+  writeJson5(paths.config, cfg);
+}
+
+export function loadWikiConfig(): WikiConfig {
+  ensureHomeDir();
+  const cfg = readJson5<WikiConfig>(paths.wikiConfig, DEFAULT_WIKI_CONFIG);
+  // backwards-compat: ensure wikis array exists
+  if (!Array.isArray(cfg.wikis)) cfg.wikis = [];
+  return { ...DEFAULT_WIKI_CONFIG, ...cfg };
+}
+
+export function saveWikiConfig(cfg: WikiConfig) {
+  ensureHomeDir();
+  writeJson5(paths.wikiConfig, cfg);
+}
+
+/** Find a wiki entry by name OR by absolute path. */
+export function findWiki(cfg: WikiConfig, nameOrPath: string): WikiEntry | undefined {
+  return cfg.wikis.find(w => w.name === nameOrPath || w.path === path.resolve(nameOrPath));
+}
+
+/**
+ * Resolve target wiki for a command:
+ * 1. If `--wiki <name>` provided, look up by name.
+ * 2. Else walk up from CWD; first match wins (by `project` or `path` prefix).
+ * 3. Return undefined if nothing matches.
+ */
+export function resolveWiki(cfg: WikiConfig, wikiFlag?: string): WikiEntry | undefined {
+  if (wikiFlag) return cfg.wikis.find(w => w.name === wikiFlag);
+  const cwd = process.cwd();
+  return cfg.wikis.find(w => cwd === w.path || cwd.startsWith(w.path + path.sep) ||
+                              (w.project && (cwd === w.project || cwd.startsWith(w.project + path.sep))));
+}

package/lib/wiki/daemon/index.ts

@@ -0,0 +1,25 @@
+import daemonInstall from './install';
+import daemonUninstall from './uninstall';
+import daemonStart from './start';
+import daemonStop from './stop';
+import daemonStatus from './status';
+import daemonLogs from './logs';
+import daemonRunner from './runner';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerDaemonCommands(parent: any): void {
+  const daemon = parent.command('daemon').description('launchd-managed background runner');
+
+  daemon.command('install').description('install ~/Library/LaunchAgents/ai.flashhand.rig.wiki.plist').action(daemonInstall);
+  daemon.command('uninstall').description('remove plist + bootout').action(daemonUninstall);
+  daemon.command('start').description('bootstrap launchd agent').action(daemonStart);
+  daemon.command('stop').description('bootout launchd agent').action(daemonStop);
+  daemon.command('status').description('print state + pid').action(daemonStatus);
+  daemon.command('logs')
+    .option('-f, --follow', 'tail -f')
+    .description('tail the daemon log')
+    .action(daemonLogs);
+
+  // hidden — launchctl invokes this; humans should never type it
+  daemon.command('runner').description('launchd entry — do not invoke directly').action(daemonRunner);
+}

package/lib/wiki/daemon/install.ts

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import print from '../../print';
+import { paths, daemonLabel } from '../paths';
+import { requireMacOS } from '../platform';
+
+function findRigEntry(): string {
+  // Walk up from this file to find the package root, then return built/index.js
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = path.join(dir, 'package.json');
+    if (fs.existsSync(pkg)) {
+      try {
+        const p = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+        if (p.name === 'rigjs') return path.join(dir, 'built', 'index.js');
+      } catch { /* keep walking */ }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error('could not locate rigjs install root');
+}
+
+function findNode(): string {
+  // Prefer /usr/local/bin/node (Homebrew Intel) then /opt/homebrew/bin/node (arm64).
+  for (const p of ['/usr/local/bin/node', '/opt/homebrew/bin/node']) {
+    if (fs.existsSync(p)) return p;
+  }
+  // Fall back to whichever node is invoking us right now.
+  return process.execPath;
+}
+
+export default function daemonInstall(): void {
+  requireMacOS();
+  fs.mkdirSync(path.dirname(paths.launchAgent), { recursive: true });
+  fs.mkdirSync(paths.logs, { recursive: true });
+
+  const nodeBin = findNode();
+  const rigEntry = findRigEntry();
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${daemonLabel}</string>
+  <key>ProgramArguments</key><array>
+    <string>${nodeBin}</string>
+    <string>${rigEntry}</string>
+    <string>wiki</string><string>daemon</string><string>runner</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${paths.daemonLog}</string>
+  <key>StandardErrorPath</key><string>${paths.daemonLog}</string>
+</dict></plist>
+`;
+  fs.writeFileSync(paths.launchAgent, plist, 'utf8');
+
+  // bootstrap (idempotent: bootout first to allow re-install)
+  const uid = process.getuid?.() ?? 0;
+  spawnSync('launchctl', ['bootout', `gui/${uid}`, paths.launchAgent], { stdio: 'ignore' });
+  const boot = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, paths.launchAgent], { stdio: 'inherit' });
+  if (boot.status !== 0) {
+    print.error('launchctl bootstrap failed');
+    process.exit(1);
+  }
+  print.succeed(`installed launchd agent ${daemonLabel}`);
+  print.info(`logs: ${paths.daemonLog}`);
+}

package/lib/wiki/daemon/logs.ts

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import { spawn } from 'child_process';
+import print from '../../print';
+import { paths } from '../paths';
+
+interface LogsOpts { follow?: boolean; }
+
+export default function daemonLogs(opts: LogsOpts): void {
+  if (!fs.existsSync(paths.daemonLog)) {
+    print.info(`no log yet at ${paths.daemonLog}`);
+    return;
+  }
+  const args = opts.follow ? ['-f', paths.daemonLog] : [paths.daemonLog];
+  const child = spawn('tail', args, { stdio: 'inherit' });
+  child.on('exit', (code) => process.exit(code ?? 0));
+}

package/lib/wiki/daemon/runner.ts

@@ -0,0 +1,42 @@
+import print from '../../print';
+import { loadWikiConfig } from '../config';
+import { paths } from '../paths';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Daemon entry. launchctl invokes:
+ *   node <rig-built>/index.js wiki daemon runner
+ *
+ * v1: minimal heartbeat loop that logs to ~/.rig/logs/wiki-daemon.log.
+ * P2 will add: cron-job registration per wiki for `schedule.scan` / `schedule.lint`,
+ * plus auto-on-new ingest from `ingestRules`.
+ */
+export default function daemonRunner(): void {
+  fs.mkdirSync(paths.logs, { recursive: true });
+  const log = (msg: string) =>
+    fs.appendFileSync(paths.daemonLog, `[${new Date().toISOString()}] ${msg}\n`);
+
+  log('rig wiki daemon: starting (v1 heartbeat-only)');
+
+  let cfg = loadWikiConfig();
+  log(`registered wikis: ${cfg.wikis.map(w => w.name).join(', ') || '(none)'}`);
+
+  // Reload config every 10 minutes so daemon doesn't need restart when wikis change.
+  setInterval(() => {
+    try {
+      cfg = loadWikiConfig();
+      log(`heartbeat — wikis=${cfg.wikis.length}`);
+    } catch (e: any) {
+      log(`heartbeat — config error: ${e.message}`);
+    }
+  }, 10 * 60 * 1000);
+
+  process.on('SIGTERM', () => { log('SIGTERM — shutting down'); process.exit(0); });
+  process.on('SIGINT',  () => { log('SIGINT — shutting down'); process.exit(0); });
+
+  // The interval keeps the event loop alive.
+  print.info(`daemon up; logging to ${paths.daemonLog}`);
+  // eslint-disable-next-line no-void
+  void path; // unused-import placeholder, retained for future cron wiring
+}

package/lib/wiki/daemon/start.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import print from '../../print';
+import { paths } from '../paths';
+import { requireMacOS } from '../platform';
+
+export default function daemonStart(): void {
+  requireMacOS();
+  if (!fs.existsSync(paths.launchAgent)) {
+    print.error('launchd agent not installed. Run `rig wiki daemon install` first.');
+    process.exit(1);
+  }
+  const uid = process.getuid?.() ?? 0;
+  const res = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, paths.launchAgent], { stdio: 'inherit' });
+  if (res.status !== 0 && res.status !== 17 /* already loaded */) {
+    print.error('launchctl bootstrap failed');
+    process.exit(1);
+  }
+  print.succeed('daemon started');
+}

package/lib/wiki/daemon/status.ts

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import print from '../../print';
+import { paths, daemonLabel } from '../paths';
+import { requireMacOS } from '../platform';
+
+export default function daemonStatus(): void {
+  requireMacOS();
+  if (!fs.existsSync(paths.launchAgent)) {
+    print.info('not installed (run `rig wiki daemon install`)');
+    return;
+  }
+  const uid = process.getuid?.() ?? 0;
+  const res = spawnSync('launchctl', ['print', `gui/${uid}/${daemonLabel}`], { encoding: 'utf8' });
+  if (res.status !== 0) {
+    print.warn('not running (installed but unloaded)');
+    return;
+  }
+  const out = res.stdout || '';
+  const state = (out.match(/state\s*=\s*(\S+)/) || [])[1] || 'unknown';
+  const pid = (out.match(/pid\s*=\s*(\d+)/) || [])[1];
+  print.info(`state=${state}${pid ? `  pid=${pid}` : ''}`);
+}

package/lib/wiki/daemon/stop.ts

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import print from '../../print';
+import { paths } from '../paths';
+import { requireMacOS } from '../platform';
+
+export default function daemonStop(): void {
+  requireMacOS();
+  if (!fs.existsSync(paths.launchAgent)) {
+    print.info('no launchd agent installed');
+    return;
+  }
+  const uid = process.getuid?.() ?? 0;
+  spawnSync('launchctl', ['bootout', `gui/${uid}`, paths.launchAgent], { stdio: 'inherit' });
+  print.succeed('daemon stopped');
+}

package/lib/wiki/daemon/uninstall.ts

@@ -0,0 +1,17 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import print from '../../print';
+import { paths } from '../paths';
+import { requireMacOS } from '../platform';
+
+export default function daemonUninstall(): void {
+  requireMacOS();
+  const uid = process.getuid?.() ?? 0;
+  if (fs.existsSync(paths.launchAgent)) {
+    spawnSync('launchctl', ['bootout', `gui/${uid}`, paths.launchAgent], { stdio: 'ignore' });
+    fs.rmSync(paths.launchAgent);
+    print.succeed(`removed ${paths.launchAgent}`);
+  } else {
+    print.info('no launchd agent installed');
+  }
+}

package/lib/wiki/db.ts

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import { paths } from './paths';
+
+// Lazy load so unit tests that don't touch the DB don't need the native binary.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Database = any;
+let cached: Database | null = null;
+
+export function getDb(): Database {
+  if (cached) return cached;
+  fs.mkdirSync(paths.home, { recursive: true });
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const BetterSqlite3 = require('better-sqlite3');
+  const db = new BetterSqlite3(paths.stateDb);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  migrate(db);
+  cached = db;
+  return db;
+}
+
+export function closeDb() {
+  if (cached) {
+    try { cached.close(); } catch { /* ignore */ }
+    cached = null;
+  }
+}
+
+function migrate(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS source_sha (
+      wiki TEXT NOT NULL,
+      path TEXT NOT NULL,
+      sha TEXT NOT NULL,
+      mtime INTEGER NOT NULL,
+      PRIMARY KEY (wiki, path)
+    );
+    CREATE TABLE IF NOT EXISTS last_run (
+      wiki TEXT NOT NULL,
+      op TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      exit_code INTEGER NOT NULL,
+      PRIMARY KEY (wiki, op)
+    );
+    CREATE TABLE IF NOT EXISTS ingest_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      wiki TEXT NOT NULL,
+      source_path TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      diff_hash TEXT NOT NULL,
+      applied INTEGER NOT NULL
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts5 USING fts5(
+      wiki, slug, body, tokenize='unicode61 remove_diacritics 2'
+    );
+  `);
+}
+
+export function recordLastRun(wiki: string, op: string, exitCode: number): void {
+  const db = getDb();
+  db.prepare(
+    `INSERT INTO last_run (wiki, op, ts, exit_code) VALUES (?, ?, ?, ?)
+     ON CONFLICT(wiki, op) DO UPDATE SET ts = excluded.ts, exit_code = excluded.exit_code`
+  ).run(wiki, op, Date.now(), exitCode);
+}
+
+export function getLastRun(wiki: string, op: string): { ts: number; exit_code: number } | undefined {
+  return getDb()
+    .prepare('SELECT ts, exit_code FROM last_run WHERE wiki = ? AND op = ?')
+    .get(wiki, op) as { ts: number; exit_code: number } | undefined;
+}