memento-mori-jester 0.1.3

package/dist/cli.js

@@ -0,0 +1,789 @@
+#!/usr/bin/env node
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { stdin as input, stdout as output } from "node:process";
+import { fileURLToPath } from "node:url";
+import { configPresetNames, defaultUserConfig, findConfigPath, loadConfig, validateConfig, writeDefaultConfig } from "./config.js";
+import { review, reviewCommand } from "./core.js";
+import { formatReview } from "./format.js";
+import { hookNames, hookStatus, installHook, isHookName, shellCommandPrefixForLocalCli, shellQuote, uninstallHook } from "./hooks.js";
+import { reviewKinds, tones } from "./types.js";
+const packageSpecDefault = "memento-mori-jester@latest";
+const args = process.argv.slice(2);
+main(args).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});
+async function main(argv) {
+    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+        output.write(helpText());
+        return;
+    }
+    if (argv[0] === "mcp-server") {
+        await import("./server.js");
+        return;
+    }
+    if (argv[0] === "mcp-config") {
+        const setupOptions = parseSetupOptions(argv.slice(1));
+        output.write(`${JSON.stringify(mcpConfigSnippet(setupOptions), null, 2)}\n`);
+        return;
+    }
+    if (argv[0] === "init") {
+        const setupOptions = parseSetupOptions(argv.slice(1));
+        output.write(renderInit(setupOptions));
+        return;
+    }
+    if (argv[0] === "bootstrap") {
+        output.write(await handleBootstrap(argv.slice(1)));
+        return;
+    }
+    if (argv[0] === "config") {
+        output.write(await handleConfigCommand(argv.slice(1)));
+        return;
+    }
+    if (argv[0] === "doctor") {
+        const doctorOptions = parseConfigCommandOptions(argv.slice(1));
+        const result = await renderDoctor(doctorOptions);
+        output.write(result.text);
+        if (!result.ok) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (argv[0] === "install-hook") {
+        const result = await handleInstallHook(argv.slice(1));
+        output.write(`${result.message}\n`);
+        return;
+    }
+    if (argv[0] === "uninstall-hook") {
+        const result = await handleUninstallHook(argv.slice(1));
+        output.write(`${result.message}\n`);
+        return;
+    }
+    if (argv[0] === "hook-status") {
+        output.write(await renderHookStatus());
+        return;
+    }
+    const { command, rest } = splitCommand(argv);
+    const options = parseOptions(rest);
+    const kind = resolveKind(command, options.kind);
+    const content = await resolveContent(options, rest);
+    if (!content.trim()) {
+        throw new Error("Nothing to review. Pass text, use --file, or pipe content on stdin.");
+    }
+    const loadedConfig = await loadConfig({
+        configPath: options.configPath,
+        search: !options.noConfig
+    });
+    const inputForReview = {
+        kind,
+        content,
+        subject: options.subject,
+        context: options.context,
+        tone: options.tone,
+        intensity: options.intensity,
+        riskTolerance: options.riskTolerance,
+        config: loadedConfig.config
+    };
+    const result = review(inputForReview);
+    output.write(options.json ? `${JSON.stringify(result, null, 2)}\n` : `${formatReview(result)}\n`);
+    if (options.failOn === "block" && result.verdict === "block") {
+        process.exitCode = 2;
+    }
+    else if (options.failOn === "caution" && result.verdict !== "pass") {
+        process.exitCode = result.verdict === "block" ? 2 : 1;
+    }
+}
+function splitCommand(argv) {
+    const [first, ...rest] = argv;
+    if (reviewKinds.includes(first) || first === "review") {
+        return { command: first, rest };
+    }
+    return { command: "review", rest: argv };
+}
+function resolveKind(command, optionKind) {
+    if (command !== "review" && reviewKinds.includes(command)) {
+        return command;
+    }
+    return optionKind ?? "plan";
+}
+function parseOptions(argv) {
+    const options = { json: false, noConfig: false };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (arg === "--json") {
+            options.json = true;
+        }
+        else if (arg === "--kind") {
+            options.kind = parseKind(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--tone") {
+            options.tone = parseTone(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--intensity") {
+            options.intensity = Number.parseInt(requireValue(arg, next), 10);
+            index += 1;
+        }
+        else if (arg === "--risk") {
+            options.riskTolerance = parseRisk(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--fail-on") {
+            options.failOn = parseFailOn(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--subject") {
+            options.subject = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--context") {
+            options.context = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--file") {
+            options.file = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--config") {
+            options.configPath = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--no-config") {
+            options.noConfig = true;
+        }
+    }
+    return options;
+}
+function parseConfigCommandOptions(argv) {
+    const options = {
+        json: false,
+        force: false,
+        noConfig: false,
+        preset: "default"
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (arg === "--json") {
+            options.json = true;
+        }
+        else if (arg === "--force") {
+            options.force = true;
+        }
+        else if (arg === "--path") {
+            options.path = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--config") {
+            options.configPath = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--no-config") {
+            options.noConfig = true;
+        }
+        else if (arg === "--preset") {
+            options.preset = parseConfigPreset(requireValue(arg, next));
+            index += 1;
+        }
+    }
+    return options;
+}
+function parseSetupOptions(argv) {
+    const options = {
+        mode: "npx",
+        agent: "generic",
+        packageSpec: packageSpecDefault,
+        tone: "court_jester",
+        intensity: 3,
+        riskTolerance: "medium",
+        json: false
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (arg === "--json") {
+            options.json = true;
+        }
+        else if (arg === "--mode") {
+            options.mode = parseSetupMode(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--agent") {
+            options.agent = parseAgent(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--package") {
+            options.packageSpec = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--tone") {
+            options.tone = parseTone(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--intensity") {
+            options.intensity = Number.parseInt(requireValue(arg, next), 10);
+            index += 1;
+        }
+        else if (arg === "--risk") {
+            options.riskTolerance = parseRisk(requireValue(arg, next));
+            index += 1;
+        }
+        else if (!arg.startsWith("--")) {
+            if (isSetupMode(arg)) {
+                options.mode = arg;
+            }
+            else if (isAgent(arg)) {
+                options.agent = arg;
+            }
+        }
+    }
+    return options;
+}
+async function resolveContent(options, argv) {
+    if (options.file) {
+        return readFile(options.file, "utf8");
+    }
+    const positional = collectPositional(argv);
+    if (positional.length > 0) {
+        return positional.join(" ");
+    }
+    if (!input.isTTY) {
+        return readStdin();
+    }
+    return "";
+}
+function collectPositional(argv) {
+    const positional = [];
+    let afterSeparator = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--") {
+            afterSeparator = true;
+            continue;
+        }
+        if (!afterSeparator && isKnownOption(arg)) {
+            index += optionHasValue(arg) ? 1 : 0;
+            continue;
+        }
+        positional.push(arg);
+    }
+    return positional;
+}
+function optionHasValue(arg) {
+    return ["--kind", "--tone", "--intensity", "--risk", "--fail-on", "--subject", "--context", "--file", "--config", "--path", "--preset"].includes(arg);
+}
+function isKnownOption(arg) {
+    return optionHasValue(arg) || ["--json", "--no-config", "--force"].includes(arg);
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        input.setEncoding("utf8");
+        input.on("data", (chunk) => {
+            data += chunk;
+        });
+        input.on("end", () => resolve(data));
+        input.on("error", reject);
+    });
+}
+function parseKind(value) {
+    if (reviewKinds.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unknown review kind "${value}". Use one of: ${reviewKinds.join(", ")}`);
+}
+function parseTone(value) {
+    if (tones.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unknown tone "${value}". Use one of: ${tones.join(", ")}`);
+}
+function parseRisk(value) {
+    if (value === "low" || value === "medium" || value === "high") {
+        return value;
+    }
+    throw new Error('Unknown risk tolerance. Use "low", "medium", or "high".');
+}
+function parseFailOn(value) {
+    if (value === "caution" || value === "block") {
+        return value;
+    }
+    throw new Error('Unknown fail threshold. Use "caution" or "block".');
+}
+function parseConfigPreset(value) {
+    if (configPresetNames.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unknown config preset "${value}". Use one of: ${configPresetNames.join(", ")}`);
+}
+function parseSetupMode(value) {
+    if (isSetupMode(value)) {
+        return value;
+    }
+    throw new Error('Unknown setup mode. Use "npx", "global", or "local".');
+}
+function isSetupMode(value) {
+    return value === "npx" || value === "global" || value === "local";
+}
+function parseAgent(value) {
+    if (isAgent(value)) {
+        return value;
+    }
+    throw new Error('Unknown agent target. Use "generic", "claude", or "codex".');
+}
+function isAgent(value) {
+    return value === "generic" || value === "claude" || value === "codex";
+}
+function requireValue(flag, value) {
+    if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${flag}.`);
+    }
+    return value;
+}
+function mcpConfigSnippet(options) {
+    return {
+        mcpServers: {
+            "memento-mori-jester": {
+                ...mcpCommandSpec(options)
+            }
+        }
+    };
+}
+function mcpCommandSpec(options) {
+    if (options.mode === "local") {
+        return {
+            command: "node",
+            args: [serverPath()]
+        };
+    }
+    if (options.mode === "global") {
+        return {
+            command: "memento-mori-jester-mcp",
+            args: []
+        };
+    }
+    return {
+        command: "npx",
+        args: ["-y", options.packageSpec, "mcp-server"]
+    };
+}
+function serverPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "server.js");
+}
+function cliPath() {
+    return fileURLToPath(import.meta.url);
+}
+function renderInit(options) {
+    const cliCommand = renderCliCommand(options);
+    const config = JSON.stringify(mcpConfigSnippet(options), null, 2);
+    const agentLine = options.agent === "generic"
+        ? "Paste this into any MCP client that accepts the standard mcpServers JSON shape."
+        : `Use this for ${options.agent}; if its config format differs, keep the command and args values.`;
+    return `Memento Mori Jester setup
+
+Try it now:
+  ${cliCommand} command "git reset --hard"
+
+MCP config (${options.mode} mode):
+${config}
+
+${agentLine}
+
+Suggested agent instruction:
+  Before risky commands, final answers, commits, or large edits, call the Memento Mori Jester. Treat BLOCK as requiring a changed plan, and CAUTION as requiring at least one concrete verification step.
+
+Useful next checks:
+  ${cliCommand} doctor
+  ${cliCommand} config init
+  ${cliCommand} install-hook pre-commit
+  ${cliCommand} plan "I will just refactor auth and ship it"
+`;
+}
+function renderCliCommand(options) {
+    if (options.mode === "global") {
+        return "jester";
+    }
+    if (options.mode === "local") {
+        return `node "${cliPath()}"`;
+    }
+    return `npx -y ${options.packageSpec}`;
+}
+async function handleConfigCommand(argv) {
+    const [subcommand = "show"] = argv;
+    const options = parseConfigCommandOptions(argv.slice(1));
+    if (subcommand === "init") {
+        const path = await writeDefaultConfig({
+            path: options.path,
+            force: options.force,
+            preset: options.preset
+        });
+        return `Wrote ${path}\n`;
+    }
+    if (subcommand === "presets") {
+        return `${configPresetNames.join("\n")}\n`;
+    }
+    if (subcommand === "show") {
+        const loaded = await loadConfig({
+            configPath: options.configPath,
+            search: !options.noConfig
+        });
+        if (options.json) {
+            return `${JSON.stringify(loaded, null, 2)}\n`;
+        }
+        const label = loaded.path ? `Loaded ${loaded.path}` : "No config file found; using built-in defaults.";
+        return `${label}\n${JSON.stringify({ ...defaultUserConfig(), ...loaded.config }, null, 2)}\n`;
+    }
+    if (subcommand === "validate") {
+        const result = await validateConfig({
+            configPath: options.configPath,
+            search: !options.noConfig
+        });
+        if (options.json) {
+            return `${JSON.stringify(result, null, 2)}\n`;
+        }
+        if (result.ok) {
+            return `Config valid: ${result.path}\n`;
+        }
+        process.exitCode = 1;
+        return `Config invalid${result.path ? `: ${result.path}` : ""}\n${result.issues.map((issue) => `- ${issue}`).join("\n")}\n`;
+    }
+    throw new Error('Unknown config command. Use "jester config init", "jester config show", "jester config validate", or "jester config presets".');
+}
+async function handleBootstrap(argv) {
+    const options = parseBootstrapOptions(argv);
+    const configFile = await ensureBootstrapConfig(options);
+    const mcpFile = await writeStarterFile({
+        relativePath: "memento-mori.mcp.json",
+        content: `${JSON.stringify(mcpConfigSnippet(options), null, 2)}\n`,
+        force: options.force
+    });
+    const instructionsFile = await writeStarterFile({
+        relativePath: "MEMENTO_MORI.md",
+        content: renderBootstrapInstructions(options),
+        force: options.force
+    });
+    const loaded = await loadConfig({ configPath: configFile.path, search: false });
+    const failOn = loaded.config.hookFailOn ?? "block";
+    const hooks = [];
+    for (const hook of options.hooks) {
+        hooks.push(await installHook({
+            hook,
+            commandPrefix: hookCommandPrefix(options),
+            failOn,
+            force: options.force
+        }));
+    }
+    const result = {
+        ok: true,
+        mode: options.mode,
+        agent: options.agent,
+        preset: options.preset,
+        files: [configFile, mcpFile, instructionsFile],
+        hooks,
+        nextSteps: [
+            `${renderCliCommand(options)} doctor`,
+            `${renderCliCommand(options)} config validate`,
+            "Add memento-mori.mcp.json to your MCP client, or copy the command and args from it."
+        ]
+    };
+    if (options.json) {
+        return `${JSON.stringify(result, null, 2)}\n`;
+    }
+    const lines = [
+        "Memento Mori Jester bootstrap",
+        "",
+        "Files:",
+        ...result.files.map((file) => `  ${file.changed ? "wrote" : "kept"} ${file.path}`),
+        ""
+    ];
+    if (hooks.length > 0) {
+        lines.push("Hooks:", ...hooks.map((hook) => `  ${hook.message}`), "");
+    }
+    lines.push("Next:", ...result.nextSteps.map((step) => `  ${step}`), "");
+    return lines.join("\n");
+}
+async function handleInstallHook(argv) {
+    const options = await parseHookCommandOptions(argv);
+    const loaded = await loadConfig({
+        configPath: options.configPath,
+        search: !options.noConfig
+    });
+    const failOn = options.failOn ?? loaded.config.hookFailOn ?? "block";
+    return installHook({
+        hook: options.hook,
+        commandPrefix: hookCommandPrefix(options.setup),
+        failOn,
+        force: options.force
+    });
+}
+async function handleUninstallHook(argv) {
+    const options = await parseHookCommandOptions(argv);
+    return uninstallHook(options.hook, { force: options.force });
+}
+async function parseHookCommandOptions(argv) {
+    const setup = parseSetupOptions(argv);
+    let hook;
+    let failOn;
+    let force = false;
+    let configPath;
+    let noConfig = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (isHookName(arg)) {
+            hook = arg;
+        }
+        else if (arg === "--fail-on") {
+            failOn = parseFailOn(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--config") {
+            configPath = requireValue(arg, next);
+            index += 1;
+        }
+        else if (arg === "--no-config") {
+            noConfig = true;
+        }
+    }
+    if (!hook) {
+        throw new Error(`Missing hook name. Use one of: ${hookNames.join(", ")}`);
+    }
+    return {
+        hook,
+        setup,
+        failOn,
+        force,
+        configPath,
+        noConfig
+    };
+}
+function parseBootstrapOptions(argv) {
+    const setup = parseSetupOptions(argv);
+    let preset = "default";
+    let force = false;
+    const hooks = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (arg === "--preset") {
+            preset = parseConfigPreset(requireValue(arg, next));
+            index += 1;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--hook") {
+            const hook = requireValue(arg, next);
+            if (!isHookName(hook)) {
+                throw new Error(`Unknown hook "${hook}". Use one of: ${hookNames.join(", ")}`);
+            }
+            hooks.push(hook);
+            index += 1;
+        }
+    }
+    return {
+        ...setup,
+        preset,
+        force,
+        hooks: [...new Set(hooks)]
+    };
+}
+async function renderHookStatus() {
+    const statuses = await hookStatus();
+    return `${statuses.map((status) => `${status.hook}: ${status.message} (${status.path})`).join("\n")}\n`;
+}
+function hookCommandPrefix(options) {
+    if (options.mode === "local") {
+        return shellCommandPrefixForLocalCli(cliPath());
+    }
+    if (options.mode === "global") {
+        return "jester";
+    }
+    return `npx -y ${shellQuote(options.packageSpec)}`;
+}
+async function renderDoctor(options) {
+    let configCheck;
+    try {
+        const loaded = await loadConfig({
+            configPath: options.configPath,
+            search: !options.noConfig
+        });
+        configCheck = {
+            name: "config",
+            ok: true,
+            detail: loaded.path ? `Loaded ${loaded.path}.` : "No config file found; using built-in defaults."
+        };
+    }
+    catch (error) {
+        configCheck = {
+            name: "config",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const checks = [
+        {
+            name: "node-version",
+            ok: nodeMajorVersion() >= 20,
+            detail: `Node ${process.version}; required >=20.`
+        },
+        {
+            name: "mcp-server-file",
+            ok: await fileExists(serverPath()),
+            detail: serverPath()
+        },
+        {
+            name: "review-engine",
+            ok: reviewCommand("git reset --hard").verdict === "block",
+            detail: "Dangerous git command is blocked."
+        },
+        configCheck
+    ];
+    const ok = checks.every((check) => check.ok);
+    if (options.json) {
+        return {
+            ok,
+            text: `${JSON.stringify({ ok, checks }, null, 2)}\n`
+        };
+    }
+    const lines = [
+        "Memento Mori Jester doctor",
+        "",
+        ...checks.map((check) => `${check.ok ? "PASS" : "FAIL"} ${check.name}: ${check.detail}`),
+        "",
+        ok
+            ? "The fool is fit for court."
+            : "Something needs fixing before the fool can be trusted with sharp objects.",
+        ""
+    ];
+    return { ok, text: lines.join("\n") };
+}
+async function ensureBootstrapConfig(options) {
+    const existing = await findConfigPath();
+    if (existing && !options.force) {
+        return {
+            path: existing,
+            changed: false,
+            message: "Kept existing config file."
+        };
+    }
+    const path = await writeDefaultConfig({ force: options.force, preset: options.preset });
+    return {
+        path,
+        changed: true,
+        message: "Wrote project config."
+    };
+}
+async function writeStarterFile(options) {
+    const path = resolve(process.cwd(), options.relativePath);
+    const exists = await fileExists(path);
+    if (exists && !options.force) {
+        return {
+            path,
+            changed: false,
+            message: `Kept existing ${options.relativePath}.`
+        };
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, options.content, "utf8");
+    return {
+        path,
+        changed: true,
+        message: `Wrote ${options.relativePath}.`
+    };
+}
+function renderBootstrapInstructions(options) {
+    const cliCommand = renderCliCommand(options);
+    return `# Memento Mori Jester
+
+## Agent Instruction
+
+Before risky commands, final answers, commits, or large edits, call the Memento Mori Jester. Treat BLOCK as requiring a changed plan, and CAUTION as requiring at least one concrete verification step.
+
+## MCP
+
+Use \`memento-mori.mcp.json\` with an MCP client, or copy the command and args from it into the client's config.
+
+## Local Checks
+
+\`\`\`powershell
+${cliCommand} doctor
+${cliCommand} config validate
+${cliCommand} command "git reset --hard"
+git diff | ${cliCommand} diff --fail-on block
+\`\`\`
+
+## Git Hooks
+
+\`\`\`powershell
+${cliCommand} install-hook pre-commit
+${cliCommand} install-hook pre-push --fail-on caution
+\`\`\`
+`;
+}
+function nodeMajorVersion() {
+    return Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function helpText() {
+    return `Memento Mori Jester
+
+Usage:
+  jester plan "I will just refactor auth and ship it"
+  jester command "Remove-Item .\\\\dist -Recurse -Force"
+  git diff | jester diff --fail-on block
+  jester final --file final-answer.txt --tone professional
+  jester init
+  jester bootstrap --preset node
+  jester doctor
+  jester config init
+  jester config init --preset security
+  jester config show
+  jester config validate
+  jester config presets
+  jester install-hook pre-commit
+  jester install-hook pre-push --fail-on caution
+  jester hook-status
+  jester mcp-config --mode npx
+  jester mcp-server
+
+Options:
+  --kind <plan|command|diff|final>     Review kind when using "review"
+  --tone <gentle_stoic|court_jester|absolute_menace|professional>
+  --intensity <1-5>
+  --risk <low|medium|high>
+  --fail-on <caution|block>            Set a non-zero exit code at this verdict
+  --subject <text>
+  --context <text>
+  --file <path>
+  --config <path>                     Use a specific jester config file
+  --no-config                         Ignore jester.config.json discovery
+  --preset <default|node|python|security>
+  --json
+
+Setup options:
+  --mode <npx|global|local>            MCP command style; default is npx
+  --agent <generic|claude|codex>       Label the generated setup guidance
+  --package <npm-or-git-spec>          Package spec used by npx mode
+  --hook <pre-commit|pre-push>         Install a hook during bootstrap; repeatable
+
+Hook options:
+  --fail-on <caution|block>            Hook failure threshold; defaults to config hookFailOn or block
+  --force                              Replace existing hooks or bootstrap files
+`;
+}
+//# sourceMappingURL=cli.js.map