@krtclcdy/tersio 2.4.0 → 2.5.0

package/cli/common.js

@@ -0,0 +1,252 @@
+// cli/common.ts — shared foundation: CLI flags, paths, exec, file/config helpers.
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { createRequire } from 'node:module';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+const IS_WINDOWS = process.platform === 'win32';
+const RTK_BINARY_NAME = IS_WINDOWS ? 'rtk.exe' : 'rtk';
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const OMP_AGENT_DIR = path.join(HOME, '.omp', 'agent');
+const OMP_PLUGINS_DIR = path.join(HOME, '.omp', 'plugins');
+const BUN_BIN_DIR = path.join(HOME, '.bun', 'bin');
+const OMP_BIN = IS_WINDOWS ? 'omp.cmd' : 'omp';
+const PACKAGE_NAME = '@krtclcdy/tersio';
+const PACKAGE_BIN = 'tersio';
+const { version: PACKAGE_VERSION } = createRequire(import.meta.url)('../package.json');
+// Session-start mode defaults for fresh installs.
+const CAVEMAN_DEFAULTS = new Set(['off', 'lite', 'full', 'ultra', 'wenyan']);
+const PONYTAIL_DEFAULTS = new Set(['off', 'lite', 'full', 'ultra', 'review']);
+const RTK_DEFAULTS = new Set(['on', 'off']);
+// ponytail: Combo preset implies all three modes. Mirrors COMBO_LEVELS in
+// extensions/shared/session-state.ts (rtk as boolean here). Single source.
+const COMBO_PRESET_MODES = {
+    off: { caveman: 'off', rtk: false, ponytail: 'off' },
+    medium: { caveman: 'lite', rtk: true, ponytail: 'lite' },
+    balanced: { caveman: 'full', rtk: true, ponytail: 'full' },
+    max: { caveman: 'ultra', rtk: true, ponytail: 'ultra' },
+};
+const COMBO_DEFAULTS = new Set(Object.keys(COMBO_PRESET_MODES));
+function parseEnum(value, valid, flag) {
+    if (value === undefined)
+        return undefined;
+    const v = value.trim().toLowerCase();
+    if (!valid.has(v)) {
+        console.error(`[fail] Invalid ${flag}: ${value}. Valid: ${[...valid].join(', ')}`);
+        process.exit(1);
+    }
+    return v;
+}
+function flagValue(name) {
+    const i = args.indexOf(name);
+    if (i !== -1)
+        return args[i + 1];
+    const prefix = `${name}=`;
+    return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+// --- CLI flags ---
+const COMMANDS = new Set(['install', 'update', 'reinstall', 'doctor', 'uninstall', 'version', 'help']);
+const args = process.argv.slice(2);
+const commandArg = args.find((arg, index) => !arg.startsWith('-') && args[index - 1] !== '--scope');
+const command = commandArg?.toLowerCase() || null;
+const unknownCommand = command !== null && !COMMANDS.has(command);
+const install = command === 'install';
+const update = command === 'update';
+const reinstall = command === 'reinstall';
+const showVersion = command === 'version' || args.includes('--version') || args.includes('-v');
+const showHelp = command === 'help' || args.includes('--help') || args.includes('-h');
+const applyUpdate = args.includes('--apply-update');
+const dryRun = args.includes('--dry-run');
+const yes = args.includes('--yes') || args.includes('-y') || install || update || reinstall || applyUpdate;
+const verbose = args.includes('--verbose');
+const doctor = command === 'doctor' || args.includes('--doctor');
+const uninstall = command === 'uninstall' || args.includes('--uninstall');
+const removePonytail = args.includes('--remove-ponytail');
+const keepPonytail = args.includes('--keep-ponytail');
+const removeRtk = args.includes('--remove-rtk');
+const scopeFlag = flagValue('--scope')?.toLowerCase() ?? null;
+// --- Profile selection (session-start mode defaults) ---
+const comboDefaultFlag = parseEnum(flagValue('--combo-default'), COMBO_DEFAULTS, '--combo-default');
+const cavemanDefaultFlag = parseEnum(flagValue('--caveman-default'), CAVEMAN_DEFAULTS, '--caveman-default');
+const ponytailDefaultFlag = parseEnum(flagValue('--ponytail-default'), PONYTAIL_DEFAULTS, '--ponytail-default');
+const rtkDefaultFlag = parseEnum(flagValue('--rtk-default'), RTK_DEFAULTS, '--rtk-default');
+const profileFlagsGiven = [comboDefaultFlag, cavemanDefaultFlag, rtkDefaultFlag, ponytailDefaultFlag]
+    .some((flag) => flag !== undefined);
+function debug(...a) {
+    if (verbose)
+        console.log('  [debug]', ...a);
+}
+const execFileP = promisify(execFile);
+async function execP(cmd, args, opts = {}) {
+    return execFileP(cmd, args, {
+        timeout: opts.timeout || 120000,
+        encoding: 'utf8',
+        ...opts,
+    });
+}
+async function writeIfChanged(dest, content, options = {}) {
+    const existing = await readTextIfExists(dest);
+    if (existing === content) {
+        debug(`${dest} already up to date`);
+        return false;
+    }
+    if (options.dryRun) {
+        console.log(`  [dry-run] would write ${dest}`);
+        return true;
+    }
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    if (existing !== null) {
+        await fs.copyFile(dest, `${dest}.bak`);
+        debug(`${path.basename(dest)} → ${path.basename(dest)}.bak`);
+    }
+    await fs.writeFile(dest, content, 'utf8');
+    console.log(`  [write] ${dest}`);
+    return true;
+}
+// omp ships 'extensions: null'; appending list items under a null scalar breaks
+// YAML parsing. Normalize null/~/[]/empty to a mapping key first.
+const EXTENSIONS_KEY_RE = /^\s*extensions\s*:/i;
+const EXTENSIONS_NULL_RE = /^\s*extensions\s*:\s*(?:\[\s*\]|null|~)?\s*$/i;
+function normalizeExtensionsKey(lines) {
+    const idx = lines.findIndex((l) => EXTENSIONS_NULL_RE.test(l));
+    if (idx === -1)
+        return false;
+    lines[idx] = 'extensions:';
+    return true;
+}
+async function writeConfigLines(configPath, lines, logMsg) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.copyFile(configPath, `${configPath}.bak`).catch(() => { });
+    await fs.writeFile(configPath, lines.join('\n'), 'utf8');
+    console.log(logMsg);
+}
+async function ensureExtensionInConfig(configPath, extensionPath, label, options = {}) {
+    const normalizedPath = extensionPath.replace(/\\/g, '/');
+    const line = `  - ${normalizedPath}`;
+    const raw = await readTextIfExists(configPath);
+    let lines = (raw || '').split('\n');
+    if (lines.some((l) => l.includes(normalizedPath))) {
+        debug(`${label} already in config.yml`);
+        return false;
+    }
+    const extLineIdx = lines.findIndex((l) => EXTENSIONS_KEY_RE.test(l));
+    if (options.dryRun) {
+        console.log(`  [dry-run] would add ${label} to config.yml: ${normalizedPath}`);
+        return true;
+    }
+    if (normalizeExtensionsKey(lines)) {
+        lines.splice(extLineIdx + 1, 0, line, '');
+    }
+    else if (extLineIdx === -1) {
+        lines.push('extensions:');
+        lines.push(line);
+        lines.push('');
+    }
+    else {
+        lines.splice(extLineIdx + 1, 0, line);
+    }
+    await writeConfigLines(configPath, lines, `  [write] Added ${label} to config.yml`);
+    return true;
+}
+async function ensureExtensionAfterConfigEntry(configPath, extensionPath, afterPath, label, options = {}) {
+    const normalizedPath = extensionPath.replace(/\\/g, '/');
+    const normalizedAfterPath = afterPath.replace(/\\/g, '/');
+    const line = `  - ${normalizedPath}`;
+    const raw = await readTextIfExists(configPath);
+    const lines = (raw || '').split('\n');
+    const existingIndex = lines.findIndex((entry) => entry.includes(normalizedPath));
+    const afterIndex = lines.findIndex((entry) => entry.includes(normalizedAfterPath));
+    if (existingIndex !== -1 && afterIndex !== -1 && existingIndex === afterIndex + 1)
+        return false;
+    if (options.dryRun) {
+        console.log(`  [dry-run] would place ${label} after Ponytail in config.yml: ${normalizedPath}`);
+        return true;
+    }
+    if (existingIndex !== -1)
+        lines.splice(existingIndex, 1);
+    const refreshedAfterIndex = lines.findIndex((entry) => entry.includes(normalizedAfterPath));
+    if (refreshedAfterIndex !== -1) {
+        lines.splice(refreshedAfterIndex + 1, 0, line);
+    }
+    else {
+        const extensionsIndex = lines.findIndex((entry) => EXTENSIONS_KEY_RE.test(entry));
+        if (extensionsIndex === -1) {
+            lines.push('extensions:', line, '');
+        }
+        else {
+            normalizeExtensionsKey(lines);
+            lines.splice(extensionsIndex + 1, 0, line);
+        }
+    }
+    await writeConfigLines(configPath, lines, `  [write] Placed ${label} after Ponytail in config.yml`);
+    return true;
+}
+function readPonytailConfig() {
+    const dir = process.env.XDG_CONFIG_HOME
+        ? path.join(process.env.XDG_CONFIG_HOME, 'ponytail')
+        : path.join(HOME, '.config', 'ponytail');
+    return { dir, path: path.join(dir, 'config.json') };
+}
+function parseJsonObject(text) {
+    if (!text)
+        return null;
+    try {
+        const parsed = JSON.parse(text.replace(/^\uFEFF/, ''));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function parsePonytailConfig(existing) {
+    return parseJsonObject(existing) ?? {};
+}
+async function patchPonytailConfig(apply, dryRunNote, writeNote, options = {}) {
+    const config = readPonytailConfig();
+    if (options.dryRun) {
+        console.log(`  [dry-run] ${dryRunNote} in ${config.path}`);
+        return;
+    }
+    const cfg = parsePonytailConfig(await readTextIfExists(config.path));
+    if (!apply(cfg)) {
+        debug('Ponytail config already up to date');
+        return;
+    }
+    await fs.mkdir(config.dir, { recursive: true });
+    await fs.writeFile(config.path, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+    console.log(`  [write] ${writeNote} in ${config.path}`);
+}
+async function ensurePonytailConfigValue(key, value, options = {}) {
+    await patchPonytailConfig((cfg) => {
+        if (cfg[key] === value)
+            return false;
+        cfg[key] = value;
+        return true;
+    }, `would set Ponytail ${key}=${value}`, `Set Ponytail ${key}=${value}`, options);
+}
+// Read plugins/package.json tolerantly; corrupt or missing files start fresh
+// with installer-managed defaults.
+async function readPluginsPackage(pkgPath) {
+    const pkg = parseJsonObject(await readTextIfExists(pkgPath)) ?? {};
+    return { ...pkg, name: pkg.name || 'omp-plugins', private: true, dependencies: pkg.dependencies || {} };
+}
+const SCOPE_MAP = { user: '1', project: '2', both: '3' };
+function relTime(ageMs) {
+    const mins = Math.floor(ageMs / 60000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins} min${mins === 1 ? '' : 's'} ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 14)
+        return `${days} day${days === 1 ? '' : 's'} ago`;
+    const weeks = Math.floor(days / 7);
+    return `${weeks} week${weeks === 1 ? '' : 's'} ago`;
+}
+export { IS_WINDOWS, RTK_BINARY_NAME, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, BUN_BIN_DIR, OMP_BIN, PACKAGE_NAME, PACKAGE_BIN, PACKAGE_VERSION, CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS, RTK_DEFAULTS, COMBO_PRESET_MODES, COMBO_DEFAULTS, parseEnum, flagValue, COMMANDS, commandArg, command, unknownCommand, install, update, reinstall, showVersion, showHelp, applyUpdate, dryRun, yes, verbose, doctor, uninstall, removePonytail, keepPonytail, removeRtk, scopeFlag, comboDefaultFlag, cavemanDefaultFlag, ponytailDefaultFlag, rtkDefaultFlag, profileFlagsGiven, debug, execFileP, execP, writeIfChanged, normalizeExtensionsKey, EXTENSIONS_KEY_RE, writeConfigLines, ensureExtensionInConfig, ensureExtensionAfterConfigEntry, readPonytailConfig, parseJsonObject, parsePonytailConfig, patchPonytailConfig, ensurePonytailConfigValue, readPluginsPackage, SCOPE_MAP, relTime, };

package/cli/doctor.js

@@ -0,0 +1,146 @@
+// cli/doctor.ts — installation health checks.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { BUN_BIN_DIR, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, OMP_BIN, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, execP, parseJsonObject, relTime, } from './common.js';
+import { runInteractivePhase } from './interactive.js';
+import { checkForUpdate } from './update.js';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+async function runDoctor() {
+    console.log('\n=== Tersio Doctor ===');
+    // Directories
+    const agentDir = OMP_AGENT_DIR;
+    const extDir = path.join(agentDir, 'extensions');
+    const configPath = path.join(agentDir, 'config.yml');
+    const pluginsDir = OMP_PLUGINS_DIR;
+    const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
+    // Ponytail
+    const ponytailPkg = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
+    const ponytailExt = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js');
+    const cavemanIndex = path.join(extDir, 'caveman-session', 'index.js');
+    const cavemanRule = path.join(extDir, 'caveman-session', 'rule.md');
+    const rtkIndex = path.join(extDir, 'rtk-session', 'index.js');
+    const updaterIndex = path.join(extDir, 'ai-addons-updater', 'index.js');
+    const comboIndex = path.join(extDir, 'combo-toggle', 'index.js');
+    const modeReinforcement = path.join(extDir, 'shared', 'mode-reinforcement.js');
+    const selfPkg = path.join(pluginsDir, 'node_modules', PACKAGE_NAME, 'package.json');
+    // Independent probes start concurrently; sections report in fixed order as
+    // their data settles. Every probe resolves instead of rejecting.
+    const probes = {
+        ompVersion: execP(OMP_BIN, ['--version']).then((r) => r.stdout.trim(), () => null),
+        agentEntries: fs.readdir(agentDir).catch(() => null),
+        extEntries: fs.readdir(extDir).catch(() => null),
+        sharedStateText: readTextIfExists(path.join(extDir, 'shared', 'session-state.js')),
+        configText: readTextIfExists(configPath),
+        ponytailPkgText: readTextIfExists(ponytailPkg),
+        ponytailExtText: readTextIfExists(ponytailExt),
+        pluginsPkgRaw: readTextIfExists(path.join(pluginsDir, 'package.json')),
+        selfPkgText: readTextIfExists(selfPkg),
+        rtkBinText: readTextIfExists(rtkBin),
+        cavemanIndexText: readTextIfExists(cavemanIndex),
+        cavemanRuleText: readTextIfExists(cavemanRule),
+        rtkIndexText: readTextIfExists(rtkIndex),
+        updaterIndexText: readTextIfExists(updaterIndex),
+        comboIndexText: readTextIfExists(comboIndex),
+        modeReinforcementText: readTextIfExists(modeReinforcement),
+        ruleMtime: fs.stat(cavemanRule).catch(() => null),
+        rtkMtime: fs.stat(rtkBin).catch(() => null),
+        ponytailMtime: fs.stat(ponytailPkg).catch(() => null),
+        updateVersion: checkForUpdate(),
+    };
+    const rtkVersionProbe = probes.rtkBinText.then((text) => text === null ? null : execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => r.stdout.trim() || r.stderr.trim() || null, (e) => {
+        const err = e;
+        return err.stdout?.trim() || err.stderr?.trim() || null;
+    }));
+    const [ompVersion, agentEntries, extEntries, sharedStateText, configText, updateVersion] = await runInteractivePhase('Checking environment and installation', () => Promise.all([
+        probes.ompVersion,
+        probes.agentEntries,
+        probes.extEntries,
+        probes.sharedStateText,
+        probes.configText,
+        probes.updateVersion,
+    ]));
+    const [cavemanIndexText, rtkIndexText, updaterIndexText, comboIndexText, modeReinforcementText, ponytailPkgText, ponytailExtText, pluginsPkgRaw, selfPkgText] = await runInteractivePhase('Checking extensions and plugins', () => Promise.all([
+        probes.cavemanIndexText,
+        probes.rtkIndexText,
+        probes.updaterIndexText,
+        probes.comboIndexText,
+        probes.modeReinforcementText,
+        probes.ponytailPkgText,
+        probes.ponytailExtText,
+        probes.pluginsPkgRaw,
+        probes.selfPkgText,
+    ]));
+    const [cavemanRuleText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime] = await runInteractivePhase('Checking add-ons', () => Promise.all([
+        probes.cavemanRuleText,
+        probes.ruleMtime,
+        probes.rtkBinText,
+        probes.rtkMtime,
+        rtkVersionProbe,
+        probes.ponytailMtime,
+    ]));
+    // Categorized output with a tally; section headers group related probes.
+    const tally = { ok: 0, missing: 0, warn: 0 };
+    function check(label, ok, detail = '') {
+        if (ok) {
+            tally.ok++;
+            console.log(`  ${label}: ok${detail ? ` ${detail}` : ''}`);
+        }
+        else {
+            tally.missing++;
+            console.log(`  ${label}: MISSING${detail ? ` ${detail}` : ''}`);
+        }
+    }
+    function warnLine(label, detail) {
+        tally.warn++;
+        console.log(`  ${label}: warn ${detail}`);
+    }
+    section('Environment');
+    check('Node', true, process.version);
+    check('OMP CLI', ompVersion !== null, ompVersion ?? '');
+    if (updateVersion)
+        warnLine('Tersio CLI', `${updateVersion} available — run tersio update`);
+    else
+        check('Tersio CLI', true, PACKAGE_VERSION);
+    console.log(`  Home: ${HOME}`);
+    section('Installation');
+    check('OMP agent dir', agentEntries !== null, agentDir);
+    check('OMP extensions dir', extEntries !== null, extDir);
+    check('OMP config.yml', configText !== null, configPath);
+    check('Shared session bridge', sharedStateText !== null);
+    section('Extensions');
+    check('Caveman extension', cavemanIndexText !== null);
+    check('RTK extension', rtkIndexText !== null);
+    check('Updater extension', updaterIndexText !== null);
+    check('Combo extension', comboIndexText !== null);
+    check('Mode reinforcement extension', modeReinforcementText !== null);
+    section('Plugins');
+    check('Ponytail package', ponytailPkgText !== null);
+    check('Ponytail extension', ponytailExtText !== null);
+    if (configText) {
+        check('Ponytail in config.yml', configText.includes('ponytail') && configText.includes('pi-extension'));
+        check('Combo in config.yml', configText.includes('combo-toggle'));
+    }
+    check('Self plugin package', selfPkgText !== null, parseJsonObject(selfPkgText)?.version ?? '');
+    const selfDep = PACKAGE_NAME in (parseJsonObject(pluginsPkgRaw)?.dependencies || {});
+    check('Self plugin in plugins/package.json', selfDep);
+    section('Add-ons');
+    const ruleAge = ruleMtime ? `updated ${relTime(Date.now() - ruleMtime.mtimeMs)}` : '';
+    check('Caveman rule', cavemanRuleText !== null, ruleAge);
+    const rtkAge = rtkMtime ? `updated ${relTime(Date.now() - rtkMtime.mtimeMs)}` : '';
+    if (rtkBinText === null)
+        check('RTK binary', false, rtkBin);
+    else {
+        const bits = [rtkVersion, rtkAge].filter(Boolean).join(', ');
+        check('RTK binary', true, bits);
+        if (!rtkVersion)
+            warnLine('RTK version', 'unavailable — binary may not be executable');
+    }
+    const ponytailAge = ponytailMtime ? `updated ${relTime(Date.now() - ponytailMtime.mtimeMs)}` : '';
+    check('Ponytail', ponytailPkgText !== null, [parseJsonObject(ponytailPkgText)?.version ?? '', ponytailAge].filter(Boolean).join(', '));
+    const total = tally.ok + tally.missing + tally.warn;
+    console.log(`\n  Summary: ${total} checks — ${tally.ok} ok, ${tally.warn} warn, ${tally.missing} missing`);
+}
+function section(name) {
+    console.log(`\n${name}`);
+}
+export { runDoctor };