@jbarket/loomai 0.5.0

package/dist/cli/inject.js

@@ -0,0 +1,298 @@
+/**
+ * loom inject — write a marker-bounded managed section into each
+ * selected harness's dotfile. Composes with user content; idempotent.
+ *
+ * This file only wires the flag-driven (non-interactive) path; the
+ * interactive wizard is added in Task 7.
+ */
+import { parseArgs } from 'node:util';
+import { createInterface } from 'node:readline/promises';
+import { assertStackVersionCompatible } from '../config.js';
+import { extractGlobalFlags, resolveEnv } from './args.js';
+import { renderJson, stderrWritable } from './io.js';
+import { multiSelect } from './tui/multi-select.js';
+import { HARNESSES, HARNESS_KEYS, isHarnessKey, resolveHarnessPath, } from '../injection/harnesses.js';
+import { renderBlock } from '../injection/render.js';
+import { writeManagedBlock, MalformedMarkersError, findMarkers, buildContent, normalizeLF, } from '../injection/writer.js';
+import { readFile } from 'node:fs/promises';
+const USAGE = `Usage: loom inject [options]
+
+Writes a managed section into each selected harness's dotfile telling
+the agent how to load identity via loom. Re-running is idempotent;
+content outside the <!-- loom:start / loom:end --> markers is preserved.
+
+Options:
+  --harness <keys>       Comma-separated subset of: ${HARNESS_KEYS.join(', ')}
+  --all                  Inject into all default harnesses (exclusive with --harness)
+  --to <path>            Override target path (valid only when exactly one harness is selected)
+  --dry-run              Print unified diff; write nothing
+  --json                 Machine-readable output
+  --context-dir <path>   Agent context dir (default: $LOOM_CONTEXT_DIR)
+  --help, -h             Show this help
+
+With no harness flags, runs the interactive wizard on a TTY; exits 2
+on non-TTY stdin.
+`;
+const wizardOverrides = new Map();
+/** Minimal line-level diff (Myers-lite via LCS table). Good enough for
+ *  a managed-block preview; avoids pulling in a dependency. */
+function lineDiff(oldText, newText) {
+    const A = oldText.split('\n');
+    const B = newText.split('\n');
+    const n = A.length, m = B.length;
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            if (A[i] === B[j])
+                lcs[i][j] = lcs[i + 1][j + 1] + 1;
+            else
+                lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0, j = 0;
+    while (i < n && j < m) {
+        if (A[i] === B[j]) {
+            out.push(` ${A[i]}`);
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            out.push(`-${A[i]}`);
+            i++;
+        }
+        else {
+            out.push(`+${B[j]}`);
+            j++;
+        }
+    }
+    while (i < n) {
+        out.push(`-${A[i]}`);
+        i++;
+    }
+    while (j < m) {
+        out.push(`+${B[j]}`);
+        j++;
+    }
+    return out;
+}
+function makeDiff(existing, next, path) {
+    const header = `--- ${path}\n+++ ${path}\n`;
+    const hunk = lineDiff(existing, next);
+    return header + hunk.join('\n') + (hunk.length ? '\n' : '');
+}
+async function planTargets(harnesses, toOverride, envHome) {
+    if (toOverride !== undefined && harnesses.length !== 1) {
+        return {
+            error: 'loom inject: --to requires exactly a single --harness value',
+            code: 2,
+        };
+    }
+    const targets = harnesses.map((key) => {
+        const override = toOverride ?? wizardOverrides.get(key);
+        return {
+            harness: HARNESSES[key],
+            path: override ?? resolveHarnessPath(HARNESSES[key], envHome),
+        };
+    });
+    wizardOverrides.clear();
+    return targets;
+}
+async function executeTargets(targets, contextDir, opts) {
+    const rows = [];
+    let hadError = false;
+    let lastError;
+    for (const t of targets) {
+        const block = renderBlock(t.harness, contextDir);
+        try {
+            if (opts.dryRun) {
+                const existing = await readFile(t.path, 'utf-8').catch((e) => {
+                    if (e.code === 'ENOENT')
+                        return null;
+                    throw e;
+                });
+                const norm = existing === null ? null : normalizeLF(existing);
+                const markers = norm === null ? null : findMarkers(norm, t.path);
+                const { next, action } = buildContent(norm, block, markers);
+                rows.push({
+                    harness: t.harness.key,
+                    path: t.path,
+                    action,
+                    bytesWritten: 0,
+                    diff: makeDiff(norm ?? '', next, t.path),
+                });
+            }
+            else {
+                const res = await writeManagedBlock(t.path, block);
+                rows.push({
+                    harness: t.harness.key,
+                    path: res.path,
+                    action: res.action,
+                    bytesWritten: res.bytesWritten,
+                });
+            }
+        }
+        catch (err) {
+            hadError = true;
+            lastError = err;
+            rows.push({
+                harness: t.harness.key,
+                path: t.path,
+                action: 'no-change',
+                bytesWritten: 0,
+            });
+        }
+    }
+    return { rows, hadError, lastError };
+}
+function humanActionLabel(action) {
+    switch (action) {
+        case 'created': return 'created';
+        case 'appended': return 'appended';
+        case 'updated': return 'updated';
+        case 'no-change': return 'no change';
+    }
+}
+function writeHumanReport(rows, io) {
+    for (const r of rows) {
+        io.stdout(`${r.harness}: ${r.path} (${humanActionLabel(r.action)})\n`);
+    }
+}
+function writeDiffReport(rows, io) {
+    for (const r of rows) {
+        if (r.diff)
+            io.stdout(r.diff);
+    }
+}
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                harness: { type: 'string' },
+                all: { type: 'boolean' },
+                to: { type: 'string' },
+                'dry-run': { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    if (parsed.values.harness !== undefined && parsed.values.all === true) {
+        io.stderr('loom inject: --harness and --all are mutually exclusive\n');
+        return 2;
+    }
+    let harnesses = null;
+    if (parsed.values.all === true) {
+        harnesses = [...HARNESS_KEYS];
+    }
+    else if (parsed.values.harness !== undefined) {
+        const parts = parsed.values.harness.split(',').map((s) => s.trim()).filter(Boolean);
+        for (const p of parts) {
+            if (!isHarnessKey(p)) {
+                io.stderr(`loom inject: unknown harness '${p}' (valid: ${HARNESS_KEYS.join(', ')})\n`);
+                return 2;
+            }
+        }
+        harnesses = parts;
+    }
+    if (harnesses === null) {
+        if (!io.stdinIsTTY) {
+            io.stderr('loom inject: --harness or --all required when stdin is not a TTY\n');
+            return 2;
+        }
+        const chosen = await multiSelect({
+            title: 'Select harnesses to inject loom into:',
+            items: HARNESS_KEYS.map((k) => {
+                const home = io.env.HOME ?? '';
+                const defaultPath = resolveHarnessPath(HARNESSES[k], io.env.HOME);
+                const display = home ? defaultPath.replace(new RegExp(`^${home}`), '~') : defaultPath;
+                return {
+                    value: k,
+                    label: HARNESSES[k].display,
+                    detail: display,
+                };
+            }),
+            initialSelected: new Set(HARNESS_KEYS),
+        });
+        if (chosen === null) {
+            io.stderr('loom inject: cancelled\n');
+            return 130;
+        }
+        harnesses = [...chosen];
+        if (harnesses.length === 0) {
+            io.stderr('loom inject: no harnesses selected\n');
+            return 2;
+        }
+        const rl = createInterface({ input: io.stdin, output: stderrWritable(io) });
+        try {
+            io.stderr('\nPress enter to accept defaults, or type a path:\n');
+            for (const k of harnesses) {
+                const defaultPath = resolveHarnessPath(HARNESSES[k], io.env.HOME);
+                const ans = (await rl.question(`  ${HARNESSES[k].display} [${defaultPath}]: `)).trim();
+                if (ans.length > 0)
+                    wizardOverrides.set(k, ans);
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const envR = resolveEnv(global, io.env);
+    try {
+        assertStackVersionCompatible(envR.contextDir);
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    const plan = await planTargets(harnesses, parsed.values.to, io.env.HOME);
+    if ('error' in plan) {
+        io.stderr(`${plan.error}\n`);
+        return plan.code;
+    }
+    const dryRun = parsed.values['dry-run'] === true;
+    const json = global.json === true;
+    let report;
+    try {
+        report = await executeTargets(plan, envR.contextDir, { dryRun });
+    }
+    catch (err) {
+        if (err instanceof MalformedMarkersError) {
+            io.stderr(`${err.message}\n`);
+            return 1;
+        }
+        io.stderr(`loom inject: ${err.message}\n`);
+        return 1;
+    }
+    if (json) {
+        renderJson(io, report.rows);
+    }
+    else if (dryRun) {
+        writeDiffReport(report.rows, io);
+    }
+    else {
+        writeHumanReport(report.rows, io);
+    }
+    if (report.hadError) {
+        if (report.lastError instanceof MalformedMarkersError) {
+            io.stderr(`${report.lastError.message}\n`);
+        }
+        else if (report.lastError) {
+            io.stderr(`loom inject: ${report.lastError.message}\n`);
+        }
+        return 1;
+    }
+    return 0;
+}

package/dist/cli/install.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;

package/dist/cli/install.js

@@ -0,0 +1,137 @@
+/**
+ * loom install — write the bundled SKILL.md into a target harness's
+ * skills directory. Flag-driven for scripting; single-select TUI on a
+ * TTY when no --harness is given. See stack spec v1 §11 (Adapters).
+ */
+import { parseArgs } from 'node:util';
+import { resolve as pathResolve } from 'node:path';
+import { extractGlobalFlags } from './args.js';
+import { renderJson } from './io.js';
+import { INSTALL_TARGETS, INSTALL_TARGET_KEYS, isInstallTargetKey, resolveSkillPath, } from '../install/harnesses.js';
+import { writeSkill } from '../install/render.js';
+import { multiSelect } from './tui/multi-select.js';
+const USAGE = `Usage: loom install [options]
+
+Writes the loom-setup skill into a target harness's skills directory.
+On a TTY with no --harness flag, runs a single-select picker.
+
+Options:
+  --harness <key>        One of: ${INSTALL_TARGET_KEYS.join(', ')}
+  --to <path>            Override destination path (requires --harness)
+  --force                Overwrite an existing skill file
+  --dry-run              Report action without writing
+  --json                 Emit { target, path, action } and suppress prose
+  --help, -h             Show this help
+
+The "other" target writes ./loom-setup-skill.md in the current directory
+unless --to overrides.
+`;
+async function pickHarnessInteractive(_io) {
+    const items = INSTALL_TARGET_KEYS.map((k) => ({
+        value: k,
+        label: INSTALL_TARGETS[k].label,
+        detail: INSTALL_TARGETS[k].skillDir ?? '(writes to current directory)',
+    }));
+    const picked = await multiSelect({
+        title: 'Install loom-setup skill into which harness?',
+        items,
+        single: true,
+    });
+    if (!picked)
+        return null;
+    const arr = [...picked];
+    if (arr.length === 0)
+        return null;
+    return arr[0];
+}
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                harness: { type: 'string' },
+                to: { type: 'string' },
+                force: { type: 'boolean' },
+                'dry-run': { type: 'boolean' },
+                json: { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const force = Boolean(parsed.values.force);
+    const dryRun = Boolean(parsed.values['dry-run']);
+    const json = Boolean(parsed.values.json) || Boolean(global.json);
+    let key;
+    if (parsed.values.harness !== undefined) {
+        if (!isInstallTargetKey(parsed.values.harness)) {
+            io.stderr(`Unknown harness: ${parsed.values.harness}. Choose one of: ${INSTALL_TARGET_KEYS.join(', ')}.\n`);
+            return 2;
+        }
+        key = parsed.values.harness;
+    }
+    else if (io.stdinIsTTY) {
+        const picked = await pickHarnessInteractive(io);
+        if (!picked) {
+            io.stderr('Cancelled.\n');
+            return 1;
+        }
+        key = picked;
+    }
+    else {
+        io.stderr(`--harness is required when stdin is not a TTY.\n${USAGE}`);
+        return 2;
+    }
+    const target = INSTALL_TARGETS[key];
+    let dest;
+    if (parsed.values.to !== undefined) {
+        dest = pathResolve(parsed.values.to);
+    }
+    else if (key === 'other') {
+        dest = pathResolve(process.cwd(), 'loom-setup-skill.md');
+    }
+    else {
+        const p = resolveSkillPath(target);
+        if (p === null) {
+            io.stderr(`Internal error: target ${key} has no skillDir and --to was not provided.\n`);
+            return 2;
+        }
+        dest = p;
+    }
+    const res = await writeSkill(dest, { force, dryRun });
+    if (json) {
+        renderJson(io, { target: key, path: res.path, action: res.action });
+        return 0;
+    }
+    const verb = actionVerb(res.action);
+    const lines = [
+        `${verb} ${res.path}`,
+        '',
+        `Next: open ${target.label}. ${firstLetterUpper(target.invoke)}.`,
+        `After the skill finishes, ${target.restart}.`,
+    ];
+    io.stdout(lines.join('\n') + '\n');
+    return 0;
+}
+function actionVerb(a) {
+    switch (a) {
+        case 'created': return 'Wrote';
+        case 'skipped-exists': return 'Already up to date at';
+        case 'skipped-stale': return 'Skill file is outdated (re-run with --force to overwrite):';
+        case 'overwritten': return 'Overwrote';
+    }
+}
+function firstLetterUpper(s) {
+    return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}

package/dist/cli/io.d.ts

@@ -0,0 +1,14 @@
+import { Writable } from 'node:stream';
+export interface IOStreams {
+    stdout: (s: string) => void;
+    stderr: (s: string) => void;
+    stdin: NodeJS.ReadableStream;
+    stdinIsTTY: boolean;
+    env: NodeJS.ProcessEnv;
+}
+export declare function realStreams(): IOStreams;
+export declare function readStdin(stdin: NodeJS.ReadableStream): Promise<string>;
+export declare function openEditor(env: NodeJS.ProcessEnv, subcommand: string, initial?: string): Promise<string>;
+export declare function readBody(io: IOStreams, subcommand: string): Promise<string>;
+export declare function renderJson(io: IOStreams, value: unknown): void;
+export declare function stderrWritable(io: IOStreams): Writable;

package/dist/cli/io.js

@@ -0,0 +1,63 @@
+/**
+ * CLI I/O — stream writers, body reader (stdin → $EDITOR fallback),
+ * and the --json vs human render dispatcher.
+ */
+import { readFile, writeFile, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { Writable } from 'node:stream';
+export function realStreams() {
+    return {
+        stdout: (s) => { process.stdout.write(s); },
+        stderr: (s) => { process.stderr.write(s); },
+        stdin: process.stdin,
+        stdinIsTTY: Boolean(process.stdin.isTTY),
+        env: process.env,
+    };
+}
+export async function readStdin(stdin) {
+    const chunks = [];
+    for await (const chunk of stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+export async function openEditor(env, subcommand, initial = '') {
+    // Spec §"Body input for write commands": $VISUAL ?? $EDITOR ?? 'vi'.
+    const editor = env.VISUAL ?? env.EDITOR ?? 'vi';
+    const randomSuffix = Math.random().toString(36).slice(2, 8);
+    const tempPath = join(tmpdir(), `loom-${subcommand}-${process.pid}-${randomSuffix}.md`);
+    await writeFile(tempPath, initial, 'utf-8');
+    await new Promise((resolve, reject) => {
+        const child = spawn(editor, [tempPath], { stdio: 'inherit' });
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`editor exited with code ${code}; temp file at ${tempPath}`));
+        });
+        child.on('error', reject);
+    });
+    const body = await readFile(tempPath, 'utf-8');
+    await unlink(tempPath).catch(() => { });
+    return body;
+}
+export async function readBody(io, subcommand) {
+    if (!io.stdinIsTTY) {
+        return (await readStdin(io.stdin)).trimEnd();
+    }
+    const body = await openEditor(io.env, subcommand);
+    return body.trimEnd();
+}
+export function renderJson(io, value) {
+    io.stdout(JSON.stringify(value, null, 2) + '\n');
+}
+export function stderrWritable(io) {
+    return new Writable({
+        write(chunk, _encoding, callback) {
+            io.stderr(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            callback();
+        },
+    });
+}

package/dist/cli/knowledge.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;