@krtclcdy/tersio 2.19.0 → 2.20.0

package/extensions/caveman-session/index.ts

@@ -0,0 +1,161 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { dirname, join } from 'node:path';
+import { readCavemanDefault } from '../shared/plugin-settings.ts';
+import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
+
+const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
+const RULE_PATH = join(CAVERN_DIR, 'rule.md');
+
+const FALLBACK_FULL_RULE = `Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+Rules:
+- Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging.
+- Fragments OK. Short synonyms. Technical terms exact. Code unchanged.
+- Pattern: [thing] [action] [reason]. [next step].
+- Not: 'Sure! I'd be happy to help you with that.'
+- Yes: 'Bug in auth middleware. Fix:'
+
+Auto-clarity: drop caveman for security warnings, irreversible actions, or when user seems confused. Resume after.`;
+
+// ponytail: synchronous read each full-mode injection; ceiling = small file, cold session start. Upgrade path: cache file contents + mtime, invalidate on change.
+function readFullRule(): string {
+  try { return readFileSync(RULE_PATH, 'utf8'); } catch { return FALLBACK_FULL_RULE; }
+}
+
+const DEFAULT_MODE = 'off';
+const INSTRUCTIONS: Record<string, string | (() => string)> = {
+  lite: `Caveman lite active for this session.
+Respond concise. Drop pleasantries, filler, and hedging. Keep complete technical substance. Code, commands, paths, errors, commits, and PR text stay normal/exact.`,
+  full: () => `Caveman full active for this session.\n${readFullRule()}`,
+  ultra: `Caveman ultra active for this session.
+Maximum terse prose. Fragments preferred. No pleasantries, no tour, no recap unless needed. Keep all technical substance exact. Code, commands, commits, PR text, paths, and errors stay normal/exact. Drop caveman for security warnings, irreversible actions, or user confusion.`,
+  wenyan: `Caveman wenyan active for this session.
+Use ultra-terse classical-Chinese-style prose only where it preserves clarity for the user. Keep technical terms, code, commands, commits, PR text, paths, and errors exact. If clarity would suffer, use caveman full instead.`,
+};
+
+function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {
+  return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
+}
+
+function isOffCommand(text: unknown): boolean {
+  const t = normalizeInputCommand(text);
+  return t === 'stop caveman' || t === 'normal mode' || t === 'caveman off';
+}
+
+export default function cavemanSessionExtension(pi: ExtensionApi): void {
+  let currentMode = DEFAULT_MODE;
+  let isActive = false;
+  let lastCtx: ExtensionCtx | undefined = undefined;
+
+  function syncStatus(ctx?: ExtensionCtx): void {
+    lastCtx = paintableCtx(lastCtx, ctx);
+    const c = lastCtx;
+    if (!c?.ui?.setStatus) return;
+    // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+    if (isComboPresetActive() || currentMode === 'off') {
+      c.ui.setStatus('caveman', undefined);
+      return;
+    }
+    paintStatusBar(c.ui, 'caveman', '🪨', `caveman: ${currentMode.toUpperCase()}`, isActive);
+  }
+
+  function setMode(mode: string, ctx?: ExtensionCtx): boolean {
+    const normalized = normalizeMode('caveman', mode);
+    if (!normalized) return false;
+    currentMode = normalized;
+    pi.appendEntry?.('caveman-mode', { mode: normalized });
+    setSharedComboMode('caveman', normalized);
+    syncStatus(ctx);
+    const active = activeModesSummary(getSharedComboState());
+    const msg = normalized === 'off'
+      ? `Caveman off. Active: ${active}.`
+      : `Caveman ${normalized} on — terse replies for this session. Active: ${active}.`;
+    ctx?.ui?.notify?.(msg, 'info');
+    return true;
+  }
+
+  pi.setLabel?.('Caveman session toggle');
+
+  // Live mirror: a /tersio or /combo switch publishes shared state — adopt
+  // it at once so the next turn injects the new mode with no session reload.
+  // Stable identity, so the bridge set dedupes across re-inits.
+  function syncFromShared(state: { caveman: string }): void {
+    const mode = normalizeMode('caveman', state.caveman);
+    if (mode) {
+      currentMode = mode;
+      syncStatus();
+    }
+  }
+  setSharedComboListener(syncFromShared);
+  pi.registerCommand?.('caveman', {
+    description: 'Toggle terse caveman replies for this session',
+    handler: async (args, ctx) => {
+      const arg = String(args || '').trim().toLowerCase();
+      if (!arg || arg === 'on') {
+        setMode('full', ctx);
+        return;
+      }
+      if (arg === 'status') {
+        ctx?.ui?.notify?.(`Caveman: ${currentMode}`, 'info');
+        return;
+      }
+      if (!setMode(arg, ctx)) {
+        ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|wenyan|off|status]', 'warning');
+      }
+    },
+  });
+
+  pi.on<InputEvent>('input', async (event) => {
+    if (event?.source === 'extension') return;
+    if (currentMode !== 'off' && isOffCommand(event?.text)) setMode('off');
+  });
+
+  function restoreMode(ctx?: ExtensionCtx): void {
+    const entries = sessionEntries(ctx);
+    // Publish the persisted combo state (incl. combo-level) before painting:
+    // bar suppression reads the in-process bridge, which is empty in a fresh
+    // host until the combo extension reconciles — and its reconcile is
+    // UI-gated. Deriving it here makes suppression independent of load order.
+    reconcileSharedComboEntries(entries);
+    // Persisted session state wins; a fresh session falls back to the
+    // installer/user-configured default (off unless configured).
+    const persisted = resolveMode(entries, '');
+    currentMode = persisted || readCavemanDefault();
+    syncStatus(ctx);
+  }
+
+  pi.on('session_start', async (_event, ctx) => {
+    restoreMode(ctx);
+    ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, 'info');
+  });
+
+  pi.on('session_branch', async (_event, ctx) => {
+    restoreMode(ctx);
+  });
+
+  pi.on('session_tree', async (_event, ctx) => {
+    restoreMode(ctx);
+  });
+
+  pi.on('agent_start', async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on('agent_end', async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on('before_agent_start', async (event: SystemPromptEvent) => {
+    const mode = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().caveman : currentMode;
+    if (!mode || mode === 'off') return;
+    const def = INSTRUCTIONS[mode];
+    if (!def) return;
+    const instruction = typeof def === 'function' ? def() : def;
+    const base = asPromptArray(event.systemPrompt);
+    return { systemPrompt: [...base, instruction] };
+  });
+}

package/extensions/combo-toggle/index.ts

@@ -0,0 +1,217 @@
+// /combo session toggle — set all three (caveman, rtk, ponytail) at once.
+// Modes: off | medium | balanced | max
+
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import {
+  activeModesSummary,
+  asPromptArray,
+  COMBO_LEVELS,
+  getSharedComboState,
+  isComboPresetActive,
+  isOmpSubagentPrompt,
+  normalizeComboLevel,
+  paintableCtx,
+  reconcileSharedComboEntries,
+  sessionEntries,
+  setSharedComboLevel,
+  setSharedComboListener,
+  setSharedComboMode,
+  systemPromptIncludes,
+} from '../shared/session-state.ts';
+import { readComboDefault, readPonytailDefault } from '../shared/plugin-settings.ts';
+import type { ComboState, ExtensionApi, ExtensionCtx, SystemPromptEvent } from '../shared/types.ts';
+
+const require = createRequire(import.meta.url);
+
+const PONYTAIL_FALLBACK_INTENSITY: Record<string, string> = {
+  lite: 'Prefer the simplest correct solution.',
+  review: 'Review only for avoidable complexity; recommend the smallest correct replacement.',
+};
+
+function ponytailFallback(mode: string): string {
+  const intensity = PONYTAIL_FALLBACK_INTENSITY[mode] ?? 'Use the minimum correct solution. Delete or reuse before adding.';
+  return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
+}
+
+function levelSummary(state: ComboState): string {
+  return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
+}
+
+function loadPonytailInstructions(mode: string): string {
+  try {
+    const installed = path.join(
+      os.homedir(),
+      '.omp',
+      'plugins',
+      'node_modules',
+      '@dietrichgebert',
+      'ponytail',
+      'hooks',
+      'ponytail-instructions.js'
+    );
+    const { getPonytailInstructions } = require(installed) as { getPonytailInstructions?: (mode: string) => string };
+    if (typeof getPonytailInstructions === 'function') return getPonytailInstructions(mode);
+  } catch { }
+  return ponytailFallback(mode);
+}
+
+export default function comboToggleExtension(pi: ExtensionApi): void {
+  pi.setLabel?.('Combo session toggle (all 3 add-ons)');
+
+  let lastCtx: ExtensionCtx | undefined = undefined;
+
+  function syncStatus(ctx?: ExtensionCtx): void {
+    lastCtx = paintableCtx(lastCtx, ctx);
+    const c = lastCtx;
+    if (!c?.ui?.setStatus) return;
+    // Single unified bar replaces the three per-extension bars while a preset is
+    // active. In custom/off, the individual bars come back and combo stays clear.
+    if (!isComboPresetActive()) {
+      c.ui.setStatus('combo', undefined);
+      return;
+    }
+    // Read the live bridge, not cached extension state: sibling extensions
+    // reconcile it from persisted entries before this one runs.
+    const state = getSharedComboState();
+    const theme = c.ui.theme;
+    const c0 = state.caveman.toUpperCase();
+    const r = state.rtk.toUpperCase();
+    const p = state.ponytail.toUpperCase();
+    const lvl = state.level.toUpperCase();
+    const label = `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`;
+    c.ui.setStatus('combo', theme?.fg ? `${theme.fg('accent', '🧩')} ${theme.fg('muted', label)}` : `🧩 ${label}`);
+    // Clobber any sibling bars another extension may have painted in a race
+    // during session_start — our bar is canonical for the duration of the preset.
+    c.ui.setStatus('caveman', undefined);
+    c.ui.setStatus('rtk', undefined);
+    c.ui.setStatus('ponytail', undefined);
+  }
+
+  // ponytail: same persistence as /combo — siblings (incl. upstream ponytail)
+  // restore from these entries, so the fallback must write them too or the
+  // preset evaporates on resume and ponytail never activates.
+  function persistPreset(level: string): void {
+    const modes = COMBO_LEVELS[level];
+    pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
+    pi.appendEntry?.('rtk-mode', { enabled: modes.rtk === 'on' });
+    pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
+    pi.appendEntry?.('combo-level', { level });
+  }
+
+  function useState(state: Readonly<ComboState>, ctx?: ExtensionCtx): Readonly<ComboState> {
+    syncStatus(ctx);
+    return state;
+  }
+
+  function reconcile(ctx?: ExtensionCtx): Readonly<ComboState> {
+    if (!ctx?.hasUI) return getSharedComboState();
+    return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
+  }
+  function listen(ctx?: ExtensionCtx): void {
+    // Stable identity: the bridge set dedupes, so repeated track()/command
+    // calls register once instead of stacking duplicate listeners.
+    if (ctx?.hasUI) setSharedComboListener(useState);
+  }
+
+  function track(ctx?: ExtensionCtx): void {
+    listen(ctx);
+    if (ctx?.hasUI) reconcile(ctx);
+  }
+
+  pi.registerCommand?.('combo', {
+    description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
+    handler: async (args, ctx) => {
+      listen(ctx);
+      const arg = String(args || '').trim().toLowerCase();
+
+      if (!arg || arg === 'status') {
+        const state = reconcile(ctx);
+        ctx?.ui?.notify?.(
+          `Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`,
+          'info'
+        );
+        return;
+      }
+
+      if (arg === 'help') {
+        ctx?.ui?.notify?.(
+          '/combo off      — disables all 3 (caveman, rtk, ponytail)\n' +
+          '/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n' +
+          '/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n' +
+          '/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra',
+          'info'
+        );
+        return;
+      }
+
+      const level = normalizeComboLevel(arg);
+      if (!level) {
+        ctx?.ui?.notify?.(
+          `Unknown combo level: ${arg}. Use: off | medium | balanced | max`,
+          'warning'
+        );
+        return;
+      }
+
+      persistPreset(level);
+      useState(setSharedComboLevel(level), ctx);
+
+      const active = activeModesSummary(getSharedComboState());
+      ctx?.ui?.notify?.(
+        level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`,
+        'info'
+      );
+    },
+  });
+
+  pi.on('session_start', async (_event, ctx) => {
+    track(ctx);
+    if (!ctx?.hasUI) syncStatus(ctx);
+    // Installer/user-configured default applies only when no persisted *mode*
+    // state exists — unrelated session entries must not block it, or the
+    // combo bar never paints on sessions that already carry other entries.
+    const entries = sessionEntries(ctx);
+    const hasModeState = entries.some((e) => e?.type === 'custom' && (
+      e.customType === 'combo-level' || e.customType === 'caveman-mode' ||
+      e.customType === 'rtk-mode' || e.customType === 'ponytail-mode'));
+    if (getSharedComboState().level === 'off' && !hasModeState) {
+      const fallback = readComboDefault();
+      if (fallback !== 'off') {
+        persistPreset(fallback);
+        useState(setSharedComboLevel(fallback), ctx);
+        ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
+      }
+    }
+    // Standalone ponytail default: no sibling extension restores it (upstream
+    // owns the command), so apply it here when nothing persisted a
+    // ponytail-mode entry. Skipped when it matches the active preset — the
+    // preset entry already covers that, no redundant write.
+    if (!entries.some((e) => e?.type === 'custom' && e.customType === 'ponytail-mode')) {
+      const ponytailFallback = readPonytailDefault();
+      if (ponytailFallback !== 'off' && ponytailFallback !== getSharedComboState().ponytail) {
+        pi.appendEntry?.('ponytail-mode', { mode: ponytailFallback });
+        useState(setSharedComboMode('ponytail', ponytailFallback), ctx);
+      }
+    }
+  });
+
+  for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+    pi.on(event, async (_event, ctx) => {
+      track(ctx);
+    });
+  }
+
+  pi.on<SystemPromptEvent>('before_agent_start', async (event, ctx) => {
+    if (ctx?.hasUI) reconcile(ctx);
+    if (!isOmpSubagentPrompt(event.systemPrompt)) return;
+
+    const mode = getSharedComboState().ponytail;
+    if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE')) return;
+    const base = asPromptArray(event.systemPrompt);
+    return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
+  });
+
+  // Slash commands only; natural-language input caused accidental toggles and has no reload context.
+}

package/extensions/lib/utils.ts

@@ -0,0 +1,162 @@
+// Shared helpers for the installer and the AI add-ons updater.
+// Node built-ins only — this module must stay dependency-free.
+
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import https from 'node:https';
+import path from 'node:path';
+
+export interface HttpOptions {
+  maxRedirects?: number;
+}
+
+// Promise.withResolvers is Node 22+; the package supports Node 18+.
+// ponytail: swap for the built-in when engines bumps to >=22.
+export function withResolvers<T>(): PromiseWithResolvers<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
+export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/src/rules/caveman-activate.md';
+
+export interface RtkPlatformSpec {
+  triple: string;
+  ext: string;
+  binary: string;
+}
+
+export interface RtkReleaseAsset {
+  name: string;
+  browser_download_url: string;
+}
+
+export interface RtkRelease {
+  tag_name?: string;
+  assets?: RtkReleaseAsset[];
+}
+
+const RTK_PLATFORM_SPECS: Record<string, RtkPlatformSpec> = {
+  'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip', binary: 'rtk.exe' },
+  'linux/x64': { triple: 'x86_64-unknown-linux-musl', ext: '.tar.gz', binary: 'rtk' },
+  'linux/arm64': { triple: 'aarch64-unknown-linux-gnu', ext: '.tar.gz', binary: 'rtk' },
+  'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+  'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+};
+
+export function rtkPlatformSpec(platform: string = process.platform, arch: string = process.arch): RtkPlatformSpec | null {
+  return RTK_PLATFORM_SPECS[`${platform}/${arch}`] || null;
+}
+
+// Single source for the 3xx+location redirect rule shared by httpsGet/httpsDownload.
+function redirectNext(res: { statusCode?: number; headers: { location?: string } }, url: string): string | null {
+  if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+    return new URL(res.headers.location, url).href;
+  }
+  return null;
+}
+
+export function httpsGet(url: string, opts: HttpOptions = {}): Promise<string> {
+  const { promise, resolve, reject } = withResolvers<string>();
+  const maxRedirects = opts.maxRedirects ?? 5;
+  const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: 'application/json,*/*' } }, (res) => {
+    const next = redirectNext(res, url);
+    if (next) {
+      if (maxRedirects <= 0) { res.resume(); reject(new Error(`Too many redirects fetching ${url}`)); return; }
+      res.resume();
+      resolve(httpsGet(next, { maxRedirects: maxRedirects - 1 }));
+      return;
+    }
+    if (res.statusCode !== 200) { res.resume(); reject(new Error(`HTTP ${res.statusCode} for ${url}`)); return; }
+    let body = '';
+    // ponytail: streamed accumulation — fine for tens of KB; stream-pipe if assets ever exceed a few MB.
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => { body += chunk; });
+    res.on('end', () => resolve(body));
+  });
+  req.on('error', reject);
+  req.setTimeout(30000, () => req.destroy(new Error(`Timeout fetching ${url}`)));
+  return promise;
+}
+
+export function httpsDownload(url: string, dest: string, opts: HttpOptions = {}): Promise<void> {
+  const { promise, resolve, reject } = withResolvers<void>();
+  const maxRedirects = opts.maxRedirects ?? 5;
+  const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: '*/*' } }, (res) => {
+    const next = redirectNext(res, url);
+    if (next) {
+      if (maxRedirects <= 0) { res.resume(); reject(new Error(`Too many redirects downloading ${url}`)); return; }
+      res.resume();
+      resolve(httpsDownload(next, dest, { maxRedirects: maxRedirects - 1 }));
+      return;
+    }
+    if (res.statusCode !== 200) { res.resume(); reject(new Error(`HTTP ${res.statusCode} for ${url}`)); return; }
+    const file = createWriteStream(dest);
+    res.pipe(file);
+    file.on('finish', () => file.close(() => resolve()));
+    file.on('error', (err) => {
+      req.destroy();
+      res.resume();
+      reject(err);
+    });
+  });
+  req.on('error', reject);
+  req.setTimeout(120000, () => req.destroy(new Error(`Timeout downloading ${url}`)));
+  return promise;
+}
+
+export async function fetchJson<T>(url: string): Promise<T> {
+  return JSON.parse(await httpsGet(url)) as T;
+}
+
+export function sha256Hex(text: string): string {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+export async function sha256File(filePath: string): Promise<string> {
+  const buf = await fs.readFile(filePath);
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+export function parseChecksum(checksumsText: string, assetName: string): string | null {
+  const target = path.basename(assetName);
+  for (const line of checksumsText.split(/\r?\n/)) {
+    const m = line.match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/);
+    if (m && path.basename(m[2]) === target) return m[1].toLowerCase();
+  }
+  return null;
+}
+
+export async function findFile(dir: string, name: string): Promise<string | null> {
+  try {
+    const ents = await fs.readdir(dir, { withFileTypes: true });
+    for (const e of ents) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        const found = await findFile(full, name);
+        if (found) return found;
+      } else if (e.isFile()) {
+        if (e.name === name) return full;
+        // Match rtk-* asset names (e.g. rtk-x86_64-unknown-linux-musl).
+        if (name === 'rtk' || name === 'rtk.exe') {
+          const base = e.name.toLowerCase();
+          if (!/\.(txt|md|json|sha256|sig|asc|pem|crt|license)$/i.test(base)) {
+            if (base === 'rtk' || base === 'rtk.exe' || /^rtk[-_.]/.test(base)) return full;
+          }
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+export async function readTextIfExists(p: string): Promise<string | null> {
+  try { return await fs.readFile(p, 'utf8'); } catch { return null; }
+}
+
+export function normalizeRtkVersion(value: string | undefined): string {
+  return String(value || '').replace(/^rtk\s+/i, '').replace(/^v/i, '').trim();
+}