polydeukes 0.6.1 → 0.8.0

package/dist/init-grok.js

@@ -1,242 +0,0 @@
-/**
- * `initGrok` — the Grok session-surface installer.
- *
- * Preflight first, then the shared project-side scaffold, then the generated hook and the
- * `.grok/hooks` JSON registration. When a Claude delegator is already on disk, the JSON
- * command names that file instead of planting a second one — two command strings would
- * spawn two judges per call.
- *
- * Nothing existing is overwritten, with one command-field exception: a grok JSON whose
- * `command` is still the grok-mjs string is rewritten to the Claude-hook command when that
- * Claude file is on disk — otherwise grok-then-claude leaves two command strings. Any entry
- * naming the Claude-hook command also takes the matcher of the `.claude/settings.json` entry
- * carrying that command, because the host collapses the two registrations only when command
- * and matcher are byte-identical; with no such entry the matcher stays. Timeout stays either
- * way, and a command that is not the grok-mjs string is left byte-identical.
- *
- * Rules and skills are not copied; `.claude/settings.json` is not written.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { findPackageJSON } from 'node:module';
-import { dirname, join } from 'node:path';
-import { isPlainObject } from '@polydeukes/core';
-import { scaffoldProject } from './scaffold-project.js';
-/** The published entry point the generated hook loads the judge through. */
-const HOOK_SPECIFIER = 'polydeukes/claude-code';
-/** The registration artifacts, as `projectRoot`-relative paths (the report vocabulary). */
-const GROK_HOOK_RELATIVE = '.grok/hooks/covenant-pretooluse.mjs';
-const GROK_JSON_RELATIVE = '.grok/hooks/covenant-pretooluse.json';
-/** The Claude delegator this installer reuses when it is already on disk. */
-const CLAUDE_HOOK_RELATIVE = '.claude/hooks/covenant-pretooluse.mjs';
-/** Where that delegator's own registration — and the matcher it was registered under — lives. */
-const CLAUDE_SETTINGS_RELATIVE = '.claude/settings.json';
-const GROK_HOOK_COMMAND = `node "$CLAUDE_PROJECT_DIR"/${GROK_HOOK_RELATIVE}`;
-const CLAUDE_HOOK_COMMAND = `node "$CLAUDE_PROJECT_DIR"/${CLAUDE_HOOK_RELATIVE}`;
-/**
- * Which calls reach the judge — Grok's mutating+shell roster plus the Claude aliases a
- * host without Grok's alias table still sends.
- */
-const HOOK_MATCHER = 'write|search_replace|run_terminal_command|Edit|Write|MultiEdit|NotebookEdit|Bash';
-/**
- * The generated hook. It carries no assembly at all, so upgrading the package upgrades the
- * judge without regenerating this file. Same text as the Claude installer besides the
- * header: the session subpath, `repoRoot` from this file's location, and `process.exitCode`
- * rather than `process.exit`.
- */
-const GENERATED_HOOK = `#!/usr/bin/env node
-/**
- * Polydeukes PreToolUse covenant hook — generated by \`pdks init grok\`.
- *
- * A delegator and nothing more: the judgment assembly lives in the \`polydeukes\` package as
- * \`runClaudeCodeHook\`, reached here through its session subpath. The package barrel would
- * work too and is the wrong door — its re-exports are eager, so every session call would
- * load the commit surface and its git adapter alongside the judge it actually needs.
- *
- * \`repoRoot\` comes from this file's own location, never from the working directory. A hook
- * is spawned with whatever directory the agent happened to hold, and what config discovery
- * and the protection list need is the project that CONTAINS this hook — always \`../..\`
- * from here.
- *
- * fail-closed: \`runClaudeCodeHook\` translates every failure it can reach into exit 2 with
- * one blocked record. This catch answers only for what it cannot reach — the package failing
- * to resolve or load at all (never installed, or installed without a build) — where no
- * telemetry writer exists yet. Recovery is installing the package again.
- */
-
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-
-try {
-  const { runClaudeCodeHook } = await import('${HOOK_SPECIFIER}');
-  const { exitCode } = await runClaudeCodeHook({ repoRoot });
-  // Assign and let the process end naturally instead of process.exit(): an explicit exit
-  // can preempt a buffered stderr write on platforms with async pipes, dropping the break
-  // reason the agent needs to read.
-  process.exitCode = exitCode;
-} catch (error) {
-  console.error(\`covenant hook failed closed: \${error?.message ?? error}\`);
-  process.exitCode = 2;
-}
-`;
-/**
- * The default preflight: is `polydeukes` installed where `projectRoot` can reach it?
- *
- * ESM resolution specifically, because that is what the generated hook's `await import(...)`
- * runs. The generated hook loads `polydeukes/claude-code`, so that is the subpath this
- * checks — a Grok-named entry point is not added.
- */
-function resolveFromProjectRoot(projectRoot) {
-    const manifestPath = findPackageJSON('polydeukes', join(projectRoot, 'package.json'));
-    if (manifestPath === undefined) {
-        throw new Error('polydeukes is not installed where this project can reach it');
-    }
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-    const subpath = isPlainObject(manifest) && isPlainObject(manifest.exports)
-        ? manifest.exports[`./${HOOK_SPECIFIER.split('/')[1]}`]
-        : undefined;
-    const target = isPlainObject(subpath) ? subpath.import : undefined;
-    if (typeof target !== 'string' || !existsSync(join(dirname(manifestPath), target))) {
-        throw new Error(`the installed polydeukes does not expose '${HOOK_SPECIFIER}' — update or rebuild it`);
-    }
-}
-/** Write one generated artifact unless it is already there, recording which happened. */
-function writeIfAbsent(projectRoot, relative, contents, report) {
-    const path = join(projectRoot, relative);
-    if (existsSync(path)) {
-        report.skipped.push(relative);
-        return;
-    }
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, contents);
-    report.created.push(relative);
-}
-/**
- * The matcher `.claude/settings.json` registered `command` under, when it has one. Anything
- * unreadable, unparseable, or shaped otherwise answers `undefined` — the caller then keeps its
- * own roster rather than narrowing the registration to a shape it could not read.
- */
-function claudeSettingsMatcherFor(projectRoot, command) {
-    const path = join(projectRoot, CLAUDE_SETTINGS_RELATIVE);
-    if (!existsSync(path)) {
-        return undefined;
-    }
-    let root;
-    try {
-        root = JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return undefined;
-    }
-    if (!isPlainObject(root) || !isPlainObject(root.hooks) || !Array.isArray(root.hooks.PreToolUse)) {
-        return undefined;
-    }
-    for (const entry of root.hooks.PreToolUse) {
-        if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
-            continue;
-        }
-        if (entry.hooks.some((hook) => isPlainObject(hook) && hook.command === command)) {
-            return typeof entry.matcher === 'string' ? entry.matcher : undefined;
-        }
-    }
-    return undefined;
-}
-function grokHookJson(command, matcher) {
-    return `${JSON.stringify({
-        hooks: {
-            PreToolUse: [
-                {
-                    matcher,
-                    hooks: [{ type: 'command', command, timeout: 60 }],
-                },
-            ],
-        },
-    }, null, 2)}\n`;
-}
-/**
- * Rewrite the grok JSON `command` from the grok-mjs string to the Claude-hook string.
- *
- * The Claude installer calls this after writing its delegator; this installer calls it on
- * re-run when that file is already on disk. Only the installer-generated grok-mjs command
- * is rewritten; any other string is the consumer's spawn target and the file is not touched.
- * Every entry naming the Claude-hook command — rewritten now or by an earlier install — takes
- * the matcher the Claude settings file registered that command under, so the host sees one
- * pair rather than two and a re-run converges. Parse failure leaves the file as it was —
- * existence is presence, not parse success.
- */
-export function retargetGrokHookCommandToClaude(projectRoot) {
-    const path = join(projectRoot, GROK_JSON_RELATIVE);
-    if (!existsSync(path)) {
-        return;
-    }
-    let root;
-    try {
-        root = JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return;
-    }
-    if (!isPlainObject(root) || !isPlainObject(root.hooks) || !Array.isArray(root.hooks.PreToolUse)) {
-        return;
-    }
-    const settingsMatcher = claudeSettingsMatcherFor(projectRoot, CLAUDE_HOOK_COMMAND);
-    let changed = false;
-    for (const entry of root.hooks.PreToolUse) {
-        if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
-            continue;
-        }
-        let namesClaudeHook = false;
-        for (const hook of entry.hooks) {
-            if (!isPlainObject(hook)) {
-                continue;
-            }
-            if (hook.command === GROK_HOOK_COMMAND) {
-                hook.command = CLAUDE_HOOK_COMMAND;
-                changed = true;
-            }
-            namesClaudeHook ||= hook.command === CLAUDE_HOOK_COMMAND;
-        }
-        // Whether this pass rewrote the command or an earlier install already did, an entry
-        // naming the Claude hook pairs with the settings entry only on the same matcher.
-        if (namesClaudeHook && settingsMatcher !== undefined && entry.matcher !== settingsMatcher) {
-            entry.matcher = settingsMatcher;
-            changed = true;
-        }
-    }
-    if (changed) {
-        writeFileSync(path, `${JSON.stringify(root, null, 2)}\n`);
-    }
-}
-/**
- * Install the Grok session surface into `spec.projectRoot`, skipping whatever is already
- * there and reporting both halves per artifact.
- *
- * Throws before any write when the package cannot be resolved from that root — that leaves
- * zero files. Translating a throw into exit 2 with the install command is the bin's job.
- */
-export function initGrok(spec) {
-    const resolvePolydeukes = spec.resolvePolydeukes ?? resolveFromProjectRoot;
-    try {
-        resolvePolydeukes(spec.projectRoot);
-    }
-    catch (error) {
-        throw new Error(`cannot use 'polydeukes' from ${spec.projectRoot} — install or update it there first ` +
-            "(e.g. 'npm install --save-dev polydeukes'), then run this command again: " +
-            `${error instanceof Error ? error.message : String(error)}`);
-    }
-    const report = scaffoldProject(spec.projectRoot);
-    const claudeHookExists = existsSync(join(spec.projectRoot, CLAUDE_HOOK_RELATIVE));
-    if (!claudeHookExists) {
-        writeIfAbsent(spec.projectRoot, GROK_HOOK_RELATIVE, GENERATED_HOOK, report);
-    }
-    const command = claudeHookExists ? CLAUDE_HOOK_COMMAND : GROK_HOOK_COMMAND;
-    const matcher = claudeHookExists
-        ? (claudeSettingsMatcherFor(spec.projectRoot, CLAUDE_HOOK_COMMAND) ?? HOOK_MATCHER)
-        : HOOK_MATCHER;
-    writeIfAbsent(spec.projectRoot, GROK_JSON_RELATIVE, grokHookJson(command, matcher), report);
-    if (claudeHookExists) {
-        retargetGrokHookCommandToClaude(spec.projectRoot);
-    }
-    return report;
-}