coaiajs 0.1.0

package/dist/src/cli.js

@@ -0,0 +1,1086 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { tash, fetch as redisFetch, disconnect as redisDisconnect } from './redis.js';
+import { readConfig } from './config.js';
+import { llm as llmCall, transcribeAudio, abstractProcess } from './llm.js';
+import { listIssues, getIssue } from './github.js';
+import { createEnvironment, findEnvironment } from './environment.js';
+import { formatTable, formatJson, formatError, formatSuccess, truncate, formatDate, formatProgress, setColorEnabled, } from './cli-helpers.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function loadModule(name) {
+    const paths = {
+        langfuse: './langfuse/index.js',
+        narrative: './narrative/index.js',
+        pde: './pde/index.js',
+        planning: './planning/index.js',
+        pipeline: './pipeline/index.js',
+    };
+    const p = paths[name];
+    if (!p)
+        throw new Error(`Unknown module: ${name}`);
+    try {
+        return (await import(p));
+    }
+    catch {
+        throw new Error(`Module '${name}' is not yet implemented. Expected at ${p}`);
+    }
+}
+async function callModule(moduleName, funcName, ...args) {
+    const mod = await loadModule(moduleName);
+    const fn = mod[funcName];
+    if (typeof fn !== 'function') {
+        throw new Error(`${moduleName}.${funcName} is not available`);
+    }
+    return fn(...args);
+}
+function globals(cmd) {
+    return cmd.optsWithGlobals();
+}
+function output(data, cmd) {
+    if (globals(cmd).json) {
+        console.log(formatJson(data));
+    }
+    else if (typeof data === 'string') {
+        console.log(data);
+    }
+    else {
+        console.log(formatJson(data));
+    }
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return '';
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(String(chunk));
+    }
+    return chunks.join('');
+}
+function resolveText(positional, opts) {
+    if (opts.file)
+        return readFileSync(resolve(opts.file), 'utf-8');
+    return positional;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function actionHandler(fn) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (err) {
+            console.error(formatError(err instanceof Error ? err.message : String(err)));
+            process.exit(1);
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Root commands
+// ---------------------------------------------------------------------------
+function registerRootCommands(program) {
+    // ── tash ─────────────────────────────────────────────────────────────
+    program
+        .command('tash')
+        .alias('m')
+        .description('Store a key-value pair in Redis')
+        .argument('<key>', 'Redis key')
+        .argument('[value]', 'Value to store')
+        .option('--file <path>', 'Read value from file')
+        .option('--ttl <seconds>', 'Time to live in seconds', parseInt)
+        .option('--verbose', 'Verbose output')
+        .action(actionHandler(async (key, value, opts, cmd) => {
+        const val = resolveText(value, opts);
+        if (!val) {
+            console.error(formatError('Value required — provide as argument or with --file'));
+            process.exit(1);
+        }
+        await tash(key, val, opts.ttl);
+        if (opts.verbose) {
+            console.log(formatSuccess(`Stored ${key} (${val.length} bytes${opts.ttl ? `, ttl=${opts.ttl}s` : ''})`));
+        }
+        else {
+            console.log(formatSuccess(`Stored ${key}`));
+        }
+    }));
+    // ── fetch ────────────────────────────────────────────────────────────
+    program
+        .command('fetch')
+        .description('Get a value from Redis')
+        .argument('<key>', 'Redis key')
+        .option('--output <path>', 'Write result to file')
+        .option('--verbose', 'Verbose output')
+        .action(actionHandler(async (key, opts, cmd) => {
+        const result = await redisFetch(key);
+        if (result === null) {
+            console.error(formatError(`Key not found: ${key}`));
+            process.exit(1);
+        }
+        if (opts.output) {
+            writeFileSync(resolve(opts.output), result);
+            console.log(formatSuccess(`Written to ${opts.output}`));
+        }
+        else {
+            output(result, cmd);
+        }
+    }));
+    // ── transcribe ───────────────────────────────────────────────────────
+    program
+        .command('transcribe')
+        .alias('t')
+        .description('Transcribe audio via Whisper')
+        .argument('<file>', 'Audio file path')
+        .option('--output <path>', 'Write transcript to file')
+        .action(actionHandler(async (file, opts, cmd) => {
+        const result = await transcribeAudio(resolve(file));
+        if (opts.output) {
+            writeFileSync(resolve(opts.output), result);
+            console.log(formatSuccess(`Transcript written to ${opts.output}`));
+        }
+        else {
+            output(result, cmd);
+        }
+    }));
+    // ── summarize ────────────────────────────────────────────────────────
+    program
+        .command('summarize')
+        .alias('s')
+        .description('Summarize text')
+        .argument('[text]', 'Text to summarize')
+        .option('--output <path>', 'Write summary to file')
+        .option('--file <path>', 'Read text from file')
+        .action(actionHandler(async (text, opts, cmd) => {
+        let input = resolveText(text, opts);
+        if (!input)
+            input = await readStdin();
+        if (!input) {
+            console.error(formatError('Text required — provide as argument, --file, or pipe via stdin'));
+            process.exit(1);
+        }
+        const result = await abstractProcess('summarize', input);
+        if (opts.output) {
+            writeFileSync(resolve(opts.output), result);
+            console.log(formatSuccess(`Summary written to ${opts.output}`));
+        }
+        else {
+            output(result, cmd);
+        }
+    }));
+    // ── p (process) ──────────────────────────────────────────────────────
+    program
+        .command('p')
+        .description('Process text with a custom tag')
+        .argument('<tag>', 'Processing tag')
+        .argument('[text]', 'Text to process')
+        .option('--output <path>', 'Write result to file')
+        .option('--file <path>', 'Read text from file')
+        .action(actionHandler(async (tag, text, opts, cmd) => {
+        let input = resolveText(text, opts);
+        if (!input)
+            input = await readStdin();
+        if (!input) {
+            console.error(formatError('Text required — provide as argument, --file, or pipe via stdin'));
+            process.exit(1);
+        }
+        const result = await abstractProcess(tag, input);
+        if (opts.output) {
+            writeFileSync(resolve(opts.output), result);
+            console.log(formatSuccess(`Result written to ${opts.output}`));
+        }
+        else {
+            output(result, cmd);
+        }
+    }));
+    // ── init ─────────────────────────────────────────────────────────────
+    program
+        .command('init')
+        .description('Create a sample coaia.json config')
+        .action(actionHandler(async () => {
+        const target = resolve('coaia.json');
+        if (existsSync(target)) {
+            console.error(formatError('coaia.json already exists'));
+            process.exit(1);
+        }
+        const sample = {
+            redis: { url: 'redis://localhost:6379' },
+            langfuse: { publicKey: '', secretKey: '', baseUrl: 'https://cloud.langfuse.com' },
+            openai: { apiKey: '', model: 'gpt-4o-mini' },
+            github: { token: '' },
+        };
+        writeFileSync(target, JSON.stringify(sample, null, 2) + '\n');
+        console.log(formatSuccess('Created coaia.json'));
+    }));
+    // ── llm ──────────────────────────────────────────────────────────────
+    program
+        .command('llm')
+        .description('Make a raw LLM call')
+        .argument('<user>', 'User message')
+        .argument('[system]', 'System message')
+        .option('--temperature <n>', 'Temperature (0-2)', parseFloat)
+        .action(actionHandler(async (user, system, opts, cmd) => {
+        const result = await llmCall(user, system, opts.temperature);
+        output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// Fuse (Langfuse) commands
+// ---------------------------------------------------------------------------
+function registerFuseCommands(program) {
+    const fuse = program
+        .command('fuse')
+        .description('Langfuse operations');
+    // ── comments ─────────────────────────────────────────────────────────
+    const comments = fuse.command('comments').description('Comment operations');
+    comments
+        .command('list')
+        .description('List comments')
+        .option('--trace-id <id>', 'Filter by trace ID')
+        .option('--page <n>', 'Page number', parseInt)
+        .option('--limit <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listComments', opts);
+        output(result, cmd);
+    }));
+    comments
+        .command('post')
+        .description('Post a comment')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--content <text>', 'Comment content')
+        .option('--author <name>', 'Author name')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'postComment', opts);
+        output(result, cmd);
+    }));
+    // ── prompts ──────────────────────────────────────────────────────────
+    const prompts = fuse.command('prompts').description('Prompt management');
+    prompts
+        .command('list')
+        .description('List prompts')
+        .option('--page <n>', 'Page number', parseInt)
+        .option('--limit <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listPrompts', opts);
+        output(result, cmd);
+    }));
+    prompts
+        .command('get')
+        .description('Get a prompt')
+        .argument('<name>', 'Prompt name')
+        .option('--version <n>', 'Prompt version', parseInt)
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('langfuse', 'getPrompt', name, opts);
+        output(result, cmd);
+    }));
+    prompts
+        .command('create')
+        .description('Create a prompt')
+        .option('--name <name>', 'Prompt name')
+        .option('--prompt <text>', 'Prompt text')
+        .option('--model <model>', 'Model name')
+        .option('--config <json>', 'Config JSON')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createPrompt', opts);
+        output(result, cmd);
+    }));
+    // ── datasets ─────────────────────────────────────────────────────────
+    const datasets = fuse.command('datasets').description('Dataset management');
+    datasets
+        .command('list')
+        .description('List datasets')
+        .option('--page <n>', 'Page number', parseInt)
+        .option('--limit <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listDatasets', opts);
+        output(result, cmd);
+    }));
+    datasets
+        .command('get')
+        .description('Get a dataset')
+        .argument('<name>', 'Dataset name')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('langfuse', 'getDataset', name);
+        output(result, cmd);
+    }));
+    datasets
+        .command('create')
+        .description('Create a dataset')
+        .option('--name <name>', 'Dataset name')
+        .option('--description <text>', 'Description')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createDataset', opts);
+        output(result, cmd);
+    }));
+    // ── sessions ─────────────────────────────────────────────────────────
+    const sessions = fuse.command('sessions').description('Session management');
+    sessions
+        .command('create')
+        .description('Create a session')
+        .option('--id <id>', 'Session ID')
+        .option('--project-id <id>', 'Project ID')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createSession', opts);
+        output(result, cmd);
+    }));
+    sessions
+        .command('addnode')
+        .description('Add a node to a session')
+        .option('--session-id <id>', 'Session ID')
+        .option('--trace-id <id>', 'Trace ID')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'addSessionNode', opts);
+        output(result, cmd);
+    }));
+    sessions
+        .command('view')
+        .description('View a session')
+        .argument('<sessionId>', 'Session ID')
+        .action(actionHandler(async (sessionId, opts, cmd) => {
+        const result = await callModule('langfuse', 'viewSession', sessionId);
+        output(result, cmd);
+    }));
+    // ── scores ───────────────────────────────────────────────────────────
+    const scores = fuse.command('scores').alias('sc').description('Score management');
+    scores
+        .command('create')
+        .description('Create a score')
+        .option('--name <name>', 'Score name')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--observation-id <id>', 'Observation ID')
+        .option('--value <n>', 'Score value', parseFloat)
+        .option('--data-type <type>', 'Data type (NUMERIC|CATEGORICAL|BOOLEAN)')
+        .option('--comment <text>', 'Comment')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createScore', opts);
+        output(result, cmd);
+    }));
+    scores
+        .command('apply')
+        .description('Apply a score config')
+        .option('--config <name>', 'Score config name')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--value <n>', 'Score value', parseFloat)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'applyScore', opts);
+        output(result, cmd);
+    }));
+    scores
+        .command('list')
+        .description('List scores')
+        .option('--trace-id <id>', 'Filter by trace ID')
+        .option('--name <name>', 'Filter by name')
+        .option('--page <n>', 'Page number', parseInt)
+        .option('--limit <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listScores', opts);
+        output(result, cmd);
+    }));
+    // ── score-configs ────────────────────────────────────────────────────
+    const scc = fuse.command('score-configs').alias('scc').description('Score config management');
+    scc
+        .command('list')
+        .description('List score configs')
+        .option('--page <n>', 'Page number', parseInt)
+        .option('--limit <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listScoreConfigs', opts);
+        output(result, cmd);
+    }));
+    scc
+        .command('get')
+        .description('Get a score config')
+        .argument('<name>', 'Config name')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('langfuse', 'getScoreConfig', name);
+        output(result, cmd);
+    }));
+    scc
+        .command('create')
+        .description('Create a score config')
+        .option('--name <name>', 'Config name')
+        .option('--data-type <type>', 'NUMERIC | CATEGORICAL | BOOLEAN')
+        .option('--description <text>', 'Description')
+        .option('--min <n>', 'Min value (NUMERIC)', parseFloat)
+        .option('--max <n>', 'Max value (NUMERIC)', parseFloat)
+        .option('--categories <json>', 'Categories JSON (CATEGORICAL)')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createScoreConfig', opts);
+        output(result, cmd);
+    }));
+    scc
+        .command('export')
+        .description('Export score configs')
+        .option('--output <path>', 'Output file path')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'exportScoreConfigs', opts);
+        output(result, cmd);
+    }));
+    scc
+        .command('import')
+        .description('Import score configs')
+        .argument('<path>', 'Config file path')
+        .action(actionHandler(async (path, opts, cmd) => {
+        const result = await callModule('langfuse', 'importScoreConfigs', resolve(path));
+        output(result, cmd);
+    }));
+    scc
+        .command('presets')
+        .description('List available presets')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listScoreConfigPresets');
+        output(result, cmd);
+    }));
+    scc
+        .command('apply')
+        .description('Apply a preset')
+        .argument('<preset>', 'Preset name')
+        .action(actionHandler(async (preset, opts, cmd) => {
+        const result = await callModule('langfuse', 'applyScoreConfigPreset', preset);
+        output(result, cmd);
+    }));
+    scc
+        .command('available')
+        .description('Show available score types')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'availableScoreTypes');
+        output(result, cmd);
+    }));
+    scc
+        .command('show')
+        .description('Show a score config in detail')
+        .argument('<name>', 'Config name')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('langfuse', 'showScoreConfig', name);
+        output(result, cmd);
+    }));
+    // ── traces ───────────────────────────────────────────────────────────
+    const traces = fuse.command('traces').description('Trace operations');
+    traces
+        .command('create')
+        .description('Create a trace')
+        .option('--name <name>', 'Trace name')
+        .option('--session-id <id>', 'Session ID')
+        .option('--input <json>', 'Input JSON')
+        .option('--metadata <json>', 'Metadata JSON')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createTrace', opts);
+        output(result, cmd);
+    }));
+    traces
+        .command('add-observation')
+        .description('Add an observation to a trace')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--name <name>', 'Observation name')
+        .option('--type <type>', 'Type: generation | span | event')
+        .option('--input <json>', 'Input JSON')
+        .option('--output <json>', 'Output JSON')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'addObservation', opts);
+        output(result, cmd);
+    }));
+    traces
+        .command('add-observations')
+        .description('Add multiple observations from a file')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--file <path>', 'JSON file with observations')
+        .action(actionHandler(async (opts, cmd) => {
+        let data = opts;
+        if (opts.file) {
+            const raw = readFileSync(resolve(opts.file), 'utf-8');
+            data = { traceId: opts.traceId, observations: JSON.parse(raw) };
+        }
+        const result = await callModule('langfuse', 'addObservations', data);
+        output(result, cmd);
+    }));
+    traces
+        .command('patch-output')
+        .description('Patch trace output')
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--output <json>', 'Output JSON')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'patchTraceOutput', opts);
+        output(result, cmd);
+    }));
+    traces
+        .command('session-view')
+        .description('View traces by session')
+        .argument('<sessionId>', 'Session ID')
+        .action(actionHandler(async (sessionId, opts, cmd) => {
+        const result = await callModule('langfuse', 'sessionView', sessionId);
+        output(result, cmd);
+    }));
+    traces
+        .command('trace-view')
+        .description('View a specific trace')
+        .argument('<traceId>', 'Trace ID')
+        .action(actionHandler(async (traceId, opts, cmd) => {
+        const result = await callModule('langfuse', 'traceView', traceId);
+        output(result, cmd);
+    }));
+    traces
+        .command('get-observation')
+        .description('Get an observation')
+        .argument('<observationId>', 'Observation ID')
+        .action(actionHandler(async (observationId, opts, cmd) => {
+        const result = await callModule('langfuse', 'getObservation', observationId);
+        output(result, cmd);
+    }));
+    // ── projects ─────────────────────────────────────────────────────────
+    fuse
+        .command('projects')
+        .description('List projects')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'listProjects');
+        output(result, cmd);
+    }));
+    // ── media ────────────────────────────────────────────────────────────
+    const media = fuse.command('media').description('Media operations');
+    media
+        .command('upload')
+        .description('Upload a media file')
+        .argument('<file>', 'File path')
+        .option('--trace-id <id>', 'Associate with trace')
+        .action(actionHandler(async (file, opts, cmd) => {
+        const result = await callModule('langfuse', 'uploadMedia', resolve(file), opts);
+        output(result, cmd);
+    }));
+    media
+        .command('get')
+        .description('Get media details')
+        .argument('<mediaId>', 'Media ID')
+        .action(actionHandler(async (mediaId, opts, cmd) => {
+        const result = await callModule('langfuse', 'getMedia', mediaId);
+        output(result, cmd);
+    }));
+    // ── dataset-items ────────────────────────────────────────────────────
+    const datasetItems = fuse.command('dataset-items').description('Dataset item operations');
+    datasetItems
+        .command('create')
+        .description('Create a dataset item')
+        .option('--dataset <name>', 'Dataset name')
+        .option('--input <json>', 'Input JSON')
+        .option('--expected <json>', 'Expected output JSON')
+        .option('--metadata <json>', 'Metadata JSON')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('langfuse', 'createDatasetItem', opts);
+        output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// Pipeline commands
+// ---------------------------------------------------------------------------
+function registerPipelineCommands(program) {
+    const pipeline = program
+        .command('pipeline')
+        .description('Pipeline template operations');
+    pipeline
+        .command('list')
+        .description('List pipeline templates')
+        .option('--path <dir>', 'Templates directory')
+        .option('--json', 'JSON output')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('pipeline', 'listTemplates', opts);
+        output(result, cmd);
+    }));
+    pipeline
+        .command('show')
+        .description('Show a pipeline template')
+        .argument('<name>', 'Template name')
+        .option('--preview', 'Preview rendered template')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('pipeline', 'showTemplate', name, opts);
+        output(result, cmd);
+    }));
+    pipeline
+        .command('create')
+        .description('Create a run from template')
+        .argument('<name>', 'Template name')
+        .option('--var <pair>', 'Template variable (KEY=value), repeatable', (val, list) => { list.push(val); return list; }, [])
+        .option('--trace-id <id>', 'Trace ID')
+        .option('--session-id <id>', 'Session ID')
+        .option('--dry-run', 'Preview without executing')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const vars = {};
+        for (const pair of opts.var) {
+            const eq = pair.indexOf('=');
+            if (eq === -1) {
+                console.error(formatError(`Invalid --var format: ${pair} (expected KEY=value)`));
+                process.exit(1);
+            }
+            vars[pair.slice(0, eq)] = pair.slice(eq + 1);
+        }
+        const result = await callModule('pipeline', 'createFromTemplate', name, {
+            variables: vars,
+            traceId: opts.traceId,
+            sessionId: opts.sessionId,
+            dryRun: opts.dryRun,
+        });
+        output(result, cmd);
+    }));
+    pipeline
+        .command('init')
+        .description('Create a new pipeline template')
+        .argument('<name>', 'Template name')
+        .action(actionHandler(async (name, opts, cmd) => {
+        const result = await callModule('pipeline', 'initTemplate', name);
+        output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// Environment commands
+// ---------------------------------------------------------------------------
+function registerEnvCommands(program) {
+    const env = program
+        .command('env')
+        .description('Environment variable management');
+    env
+        .command('init')
+        .description('Initialize environment file')
+        .action(actionHandler(async () => {
+        const mgr = createEnvironment();
+        mgr.init();
+        console.log(formatSuccess(`Initialized ${mgr.getFilePath()}`));
+    }));
+    env
+        .command('list')
+        .description('List environment variables')
+        .action(actionHandler(async (opts, cmd) => {
+        const mgr = findEnvironment();
+        const vars = mgr.list();
+        if (globals(cmd).json) {
+            console.log(formatJson(vars));
+        }
+        else {
+            const entries = Object.entries(vars);
+            if (entries.length === 0) {
+                console.log('(no variables set)');
+            }
+            else {
+                console.log(formatTable(['Key', 'Value'], entries.map(([k, v]) => [k, truncate(v, 60)])));
+            }
+        }
+    }));
+    env
+        .command('source')
+        .description('Load env vars into process')
+        .action(actionHandler(async () => {
+        const mgr = findEnvironment();
+        mgr.source();
+        console.log(formatSuccess('Environment loaded'));
+    }));
+    env
+        .command('set')
+        .description('Set an environment variable')
+        .argument('<key>', 'Variable name')
+        .argument('<value>', 'Variable value')
+        .action(actionHandler(async (key, value) => {
+        const mgr = findEnvironment();
+        mgr.set(key, value);
+        console.log(formatSuccess(`Set ${key}`));
+    }));
+    env
+        .command('get')
+        .description('Get an environment variable')
+        .argument('<key>', 'Variable name')
+        .action(actionHandler(async (key, opts, cmd) => {
+        const mgr = findEnvironment();
+        const value = mgr.get(key);
+        if (value === undefined) {
+            console.error(formatError(`Variable not set: ${key}`));
+            process.exit(1);
+        }
+        output(value, cmd);
+    }));
+    env
+        .command('unset')
+        .description('Remove an environment variable')
+        .argument('<key>', 'Variable name')
+        .action(actionHandler(async (key) => {
+        const mgr = findEnvironment();
+        mgr.unset(key);
+        console.log(formatSuccess(`Unset ${key}`));
+    }));
+    env
+        .command('clear')
+        .description('Remove environment file')
+        .action(actionHandler(async () => {
+        const mgr = findEnvironment();
+        mgr.clear();
+        console.log(formatSuccess('Environment cleared'));
+    }));
+    env
+        .command('save')
+        .description('Save current context')
+        .action(actionHandler(async () => {
+        const mgr = findEnvironment();
+        mgr.save();
+        console.log(formatSuccess(`Saved to ${mgr.getFilePath()}`));
+    }));
+}
+// ---------------------------------------------------------------------------
+// GitHub commands
+// ---------------------------------------------------------------------------
+function registerGhCommands(program) {
+    const gh = program
+        .command('gh')
+        .description('GitHub operations');
+    const issues = gh.command('issues').description('Issue operations');
+    issues
+        .command('list')
+        .description('List issues')
+        .requiredOption('--owner <owner>', 'Repository owner')
+        .requiredOption('--repo <repo>', 'Repository name')
+        .option('--state <state>', 'Filter: open | closed | all', 'open')
+        .option('--labels <labels>', 'Comma-separated labels')
+        .option('--per-page <n>', 'Results per page', parseInt)
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await listIssues(opts.owner, opts.repo, {
+            state: opts.state,
+            labels: opts.labels,
+            per_page: opts.perPage,
+        });
+        if (globals(cmd).json) {
+            console.log(formatJson(result));
+        }
+        else {
+            console.log(formatTable(['#', 'State', 'Title', 'Labels', 'Updated'], result.map(i => [
+                String(i.number),
+                i.state,
+                truncate(i.title, 50),
+                i.labels.map(l => l.name).join(', '),
+                formatDate(i.updated_at),
+            ])));
+        }
+    }));
+    issues
+        .command('get')
+        .description('Get an issue (owner/repo#123 or number with --owner/--repo)')
+        .argument('<spec>', 'Issue spec: owner/repo#123 or issue number')
+        .option('--owner <owner>', 'Repository owner')
+        .option('--repo <repo>', 'Repository name')
+        .action(actionHandler(async (spec, opts, cmd) => {
+        let owner = opts.owner;
+        let repo = opts.repo;
+        let num;
+        const match = spec.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+        if (match) {
+            owner = match[1];
+            repo = match[2];
+            num = parseInt(match[3], 10);
+        }
+        else {
+            num = parseInt(spec, 10);
+            if (isNaN(num) || !owner || !repo) {
+                console.error(formatError('Provide owner/repo#number or a number with --owner and --repo'));
+                process.exit(1);
+            }
+        }
+        const issue = await getIssue(owner, repo, num);
+        if (globals(cmd).json) {
+            console.log(formatJson(issue));
+        }
+        else {
+            console.log([
+                `${chalk.bold(`#${issue.number}`)} ${issue.title}`,
+                `State: ${issue.state}  Author: ${issue.user?.login ?? '?'}`,
+                `Labels: ${issue.labels.map(l => l.name).join(', ') || '(none)'}`,
+                `URL: ${issue.html_url}`,
+                '',
+                issue.body ?? '(no body)',
+            ].join('\n'));
+        }
+    }));
+}
+// ---------------------------------------------------------------------------
+// Narrative commands
+// ---------------------------------------------------------------------------
+function registerNarrativeCommands(program) {
+    const narr = program
+        .command('narrative')
+        .alias('n')
+        .description('Structural tension narrative operations');
+    narr
+        .command('list')
+        .alias('ls')
+        .description('List active charts')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('narrative', 'listCharts', globals(cmd));
+        output(result, cmd);
+    }));
+    narr
+        .command('view')
+        .alias('v')
+        .description('View chart details')
+        .argument('<chartId>', 'Chart ID')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'viewChart', chartId, globals(cmd));
+        output(result, cmd);
+    }));
+    narr
+        .command('current')
+        .alias('cur')
+        .description('Show or set the current chart')
+        .argument('[chartId]', 'Chart ID to set as current')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        if (chartId) {
+            await callModule('narrative', 'setCurrentChart', chartId);
+            console.log(formatSuccess(`Current chart set to ${chartId}`));
+        }
+        else {
+            const result = await callModule('narrative', 'getCurrentChart');
+            output(result, cmd);
+        }
+    }));
+    narr
+        .command('update')
+        .alias('up')
+        .description('Update a chart')
+        .argument('<chartId>', 'Chart ID')
+        .option('--desired-outcome <text>', 'New desired outcome')
+        .option('--current-reality <text>', 'New current reality observation')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'updateChart', chartId, opts);
+        output(result, cmd);
+    }));
+    narr
+        .command('add-action')
+        .alias('aa')
+        .description('Add an action step to a chart')
+        .argument('<chartId>', 'Chart ID')
+        .option('--title <text>', 'Action step title')
+        .option('--current-reality <text>', 'Current reality for this step')
+        .option('--due <date>', 'Due date (ISO)')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'addAction', chartId, opts);
+        output(result, cmd);
+    }));
+    narr
+        .command('add-obs')
+        .alias('ao')
+        .description('Add an observation to a chart')
+        .argument('<chartId>', 'Chart ID')
+        .argument('[text...]', 'Observation text')
+        .action(actionHandler(async (chartId, text, opts, cmd) => {
+        const observation = text.join(' ');
+        if (!observation) {
+            console.error(formatError('Observation text required'));
+            process.exit(1);
+        }
+        const result = await callModule('narrative', 'addObservation', chartId, observation);
+        output(result, cmd);
+    }));
+    narr
+        .command('complete')
+        .alias('done')
+        .description('Mark an action step complete')
+        .argument('<actionName>', 'Action step name')
+        .action(actionHandler(async (actionName, opts, cmd) => {
+        const result = await callModule('narrative', 'completeAction', actionName);
+        if (typeof result === 'string')
+            console.log(formatSuccess(result));
+        else
+            output(result, cmd);
+    }));
+    narr
+        .command('export')
+        .alias('exp')
+        .description('Export a chart to markdown')
+        .argument('<chartId>', 'Chart ID')
+        .option('--output <path>', 'Output file path')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'exportChart', chartId);
+        if (opts.output) {
+            writeFileSync(resolve(opts.output), result);
+            console.log(formatSuccess(`Exported to ${opts.output}`));
+        }
+        else {
+            console.log(result);
+        }
+    }));
+    narr
+        .command('export-all')
+        .description('Export all charts to markdown')
+        .option('--output <dir>', 'Output directory')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('narrative', 'exportAllCharts', opts);
+        output(result, cmd);
+    }));
+    narr
+        .command('stats')
+        .alias('st')
+        .description('Show chart statistics')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('narrative', 'getStats', globals(cmd));
+        output(result, cmd);
+    }));
+    narr
+        .command('progress')
+        .alias('pg')
+        .description('Progress report for a chart')
+        .argument('<chartId>', 'Chart ID')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'getProgress', chartId);
+        if (globals(cmd).json) {
+            console.log(formatJson(result));
+        }
+        else if (result &&
+            typeof result === 'object' &&
+            'completed' in result &&
+            'total' in result) {
+            const r = result;
+            console.log(`${chalk.bold(r.chartId)}  ${formatProgress(r.completed, r.total)}`);
+        }
+        else {
+            output(result, cmd);
+        }
+    }));
+    narr
+        .command('mmot')
+        .description('Run MMOT evaluation on a chart')
+        .argument('<chartId>', 'Chart ID')
+        .option('--assessment <text>', 'Assessment text')
+        .option('--direction <dir>', 'Direction: South | East | West | North')
+        .action(actionHandler(async (chartId, opts, cmd) => {
+        const result = await callModule('narrative', 'performMmot', chartId, opts);
+        output(result, cmd);
+    }));
+    narr
+        .command('set-date')
+        .alias('sd')
+        .description('Set due date on a chart')
+        .argument('<chartId>', 'Chart ID')
+        .argument('<date>', 'Due date (ISO)')
+        .action(actionHandler(async (chartId, date, opts, cmd) => {
+        const result = await callModule('narrative', 'setDueDate', chartId, date);
+        if (typeof result === 'string')
+            console.log(formatSuccess(result));
+        else
+            output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// PDE commands
+// ---------------------------------------------------------------------------
+function registerPdeCommands(program) {
+    const pde = program
+        .command('pde')
+        .description('Prompt Decomposition Engine');
+    pde
+        .command('import')
+        .description('Import a PDE decomposition into narrative')
+        .argument('<pdeId>', 'Decomposition ID')
+        .action(actionHandler(async (pdeId, opts, cmd) => {
+        const result = await callModule('pde', 'importDecomposition', pdeId);
+        output(result, cmd);
+    }));
+    pde
+        .command('list')
+        .description('List decompositions')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('pde', 'listDecompositions');
+        output(result, cmd);
+    }));
+    pde
+        .command('sessions')
+        .description('List PDE sessions')
+        .action(actionHandler(async (opts, cmd) => {
+        const result = await callModule('pde', 'listSessions');
+        output(result, cmd);
+    }));
+    pde
+        .command('show')
+        .description('Show session details')
+        .argument('<sessionId>', 'Session ID')
+        .action(actionHandler(async (sessionId, opts, cmd) => {
+        const result = await callModule('pde', 'showSession', sessionId);
+        output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// Planning commands
+// ---------------------------------------------------------------------------
+function registerPlanCommands(program) {
+    const plan = program
+        .command('plan')
+        .description('Structural tension plan operations');
+    plan
+        .command('parse')
+        .description('Parse a plan file structurally')
+        .argument('<planPath>', 'Path to plan file')
+        .action(actionHandler(async (planPath, opts, cmd) => {
+        const result = await callModule('planning', 'parsePlan', resolve(planPath));
+        output(result, cmd);
+    }));
+    plan
+        .command('convert')
+        .description('Convert a plan to a structural tension chart')
+        .argument('<planPath>', 'Path to plan file')
+        .action(actionHandler(async (planPath, opts, cmd) => {
+        const result = await callModule('planning', 'convertToChart', resolve(planPath));
+        output(result, cmd);
+    }));
+    plan
+        .command('sync-to-chart')
+        .description('Sync a plan file into charts')
+        .argument('<planPath>', 'Path to plan file')
+        .argument('<chartsPath>', 'Path to charts JSONL')
+        .action(actionHandler(async (planPath, chartsPath, opts, cmd) => {
+        const result = await callModule('planning', 'syncToChart', resolve(planPath), resolve(chartsPath));
+        output(result, cmd);
+    }));
+    plan
+        .command('sync-to-plan')
+        .description('Sync chart data back to a plan file')
+        .argument('<chartsPath>', 'Path to charts JSONL')
+        .argument('<planPath>', 'Path to plan file')
+        .action(actionHandler(async (chartsPath, planPath, opts, cmd) => {
+        const result = await callModule('planning', 'syncToPlan', resolve(chartsPath), resolve(planPath));
+        output(result, cmd);
+    }));
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const program = new Command();
+    program
+        .name('coaia')
+        .version('0.1.0', '-V, --version')
+        .description('CoAIA unified CLI — structural tension, narrative, and DevOps tooling')
+        .option('--env <path>', 'Load environment file')
+        .option('-M, --memory-path <path>', 'JSONL memory file path')
+        .option('--no-color', 'Disable colors')
+        .option('--json', 'JSON output', false);
+    program.hook('preAction', (_thisCmd, actionCmd) => {
+        const opts = actionCmd.optsWithGlobals();
+        if (opts.color === false) {
+            setColorEnabled(false);
+        }
+        if (opts.env) {
+            readConfig(opts.env);
+        }
+    });
+    registerRootCommands(program);
+    registerFuseCommands(program);
+    registerPipelineCommands(program);
+    registerEnvCommands(program);
+    registerGhCommands(program);
+    registerNarrativeCommands(program);
+    registerPdeCommands(program);
+    registerPlanCommands(program);
+    program.hook('postAction', async () => {
+        try {
+            await redisDisconnect();
+        }
+        catch { /* client may not have been initialized */ }
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    console.error(formatError(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map