@longtable/cli 0.1.31 → 0.1.33

package/dist/codex-hooks.js

@@ -0,0 +1,240 @@
+import { join } from "node:path";
+export const LONGTABLE_MANAGED_HOOK_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop"
+];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJson(value) {
+    return structuredClone(value);
+}
+function buildCommandHook(command, options = {}) {
+    const hook = {
+        type: "command",
+        command,
+        ...(options.statusMessage ? { statusMessage: options.statusMessage } : {}),
+        ...(typeof options.timeout === "number" ? { timeout: options.timeout } : {})
+    };
+    return {
+        ...(options.matcher ? { matcher: options.matcher } : {}),
+        hooks: [hook]
+    };
+}
+export function buildManagedCodexHooksConfig(packageRoot) {
+    const hookScript = join(packageRoot, "dist", "longtable-codex-native-hook.js");
+    const command = `node "${hookScript}"`;
+    return {
+        hooks: {
+            SessionStart: [
+                buildCommandHook(command, {
+                    matcher: "startup|resume"
+                })
+            ],
+            PreToolUse: [
+                buildCommandHook(command, {
+                    matcher: "Bash",
+                    statusMessage: "Running LongTable checkpoint guard"
+                })
+            ],
+            PostToolUse: [
+                buildCommandHook(command, {
+                    matcher: "Bash",
+                    statusMessage: "Reviewing LongTable post-tool state"
+                })
+            ],
+            UserPromptSubmit: [
+                buildCommandHook(command, {
+                    statusMessage: "Applying LongTable research context"
+                })
+            ],
+            Stop: [
+                buildCommandHook(command, {
+                    timeout: 30
+                })
+            ]
+        }
+    };
+}
+export function parseCodexHooksConfig(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (!isPlainObject(parsed)) {
+            return null;
+        }
+        return {
+            root: cloneJson(parsed),
+            hooks: isPlainObject(parsed.hooks) ? cloneJson(parsed.hooks) : {}
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function isLongTableManagedHookCommand(command) {
+    return /(?:^|[\\/])longtable-codex-native-hook\.js(?:["'\s]|$)/.test(command);
+}
+function countManagedHooksInEntry(entry) {
+    if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+        return 0;
+    }
+    return entry.hooks.filter((hook) => isPlainObject(hook) &&
+        hook.type === "command" &&
+        typeof hook.command === "string" &&
+        isLongTableManagedHookCommand(hook.command)).length;
+}
+export function getMissingManagedCodexHookEvents(content) {
+    const parsed = parseCodexHooksConfig(content);
+    if (!parsed) {
+        return null;
+    }
+    return LONGTABLE_MANAGED_HOOK_EVENTS.filter((eventName) => {
+        const entries = Array.isArray(parsed.hooks[eventName]) ? parsed.hooks[eventName] : [];
+        return !entries.some((entry) => countManagedHooksInEntry(entry) > 0);
+    });
+}
+function stripManagedHooksFromEntry(entry) {
+    if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+        return { entry: cloneJson(entry), removedCount: 0 };
+    }
+    const nextHooks = entry.hooks.filter((hook) => {
+        if (!isPlainObject(hook)) {
+            return true;
+        }
+        return !(hook.type === "command" &&
+            typeof hook.command === "string" &&
+            isLongTableManagedHookCommand(hook.command));
+    });
+    const removedCount = entry.hooks.length - nextHooks.length;
+    if (removedCount === 0) {
+        return { entry: cloneJson(entry), removedCount: 0 };
+    }
+    if (nextHooks.length === 0) {
+        return { entry: null, removedCount };
+    }
+    return {
+        entry: {
+            ...cloneJson(entry),
+            hooks: nextHooks
+        },
+        removedCount
+    };
+}
+function serializeCodexHooksConfig(root) {
+    return JSON.stringify(root, null, 2) + "\n";
+}
+export function mergeManagedCodexHooksConfig(existingContent, packageRoot) {
+    const managedConfig = buildManagedCodexHooksConfig(packageRoot);
+    const parsed = typeof existingContent === "string"
+        ? parseCodexHooksConfig(existingContent)
+        : null;
+    const nextRoot = parsed ? cloneJson(parsed.root) : {};
+    const nextHooks = parsed ? cloneJson(parsed.hooks) : {};
+    for (const eventName of LONGTABLE_MANAGED_HOOK_EVENTS) {
+        const existingEntries = Array.isArray(nextHooks[eventName]) ? nextHooks[eventName] : [];
+        const preservedEntries = [];
+        for (const entry of existingEntries) {
+            const stripped = stripManagedHooksFromEntry(entry);
+            if (stripped.entry !== null) {
+                preservedEntries.push(stripped.entry);
+            }
+        }
+        nextHooks[eventName] = [
+            ...preservedEntries,
+            ...managedConfig.hooks[eventName].map((entry) => cloneJson(entry))
+        ];
+    }
+    nextRoot.hooks = nextHooks;
+    return serializeCodexHooksConfig(nextRoot);
+}
+export function removeManagedCodexHooks(existingContent) {
+    const parsed = parseCodexHooksConfig(existingContent);
+    if (!parsed) {
+        return { nextContent: existingContent, removedCount: 0 };
+    }
+    const nextRoot = cloneJson(parsed.root);
+    const nextHooks = cloneJson(parsed.hooks);
+    let removedCount = 0;
+    for (const [eventName, rawEntries] of Object.entries(nextHooks)) {
+        if (!Array.isArray(rawEntries)) {
+            continue;
+        }
+        const preservedEntries = [];
+        for (const entry of rawEntries) {
+            const stripped = stripManagedHooksFromEntry(entry);
+            removedCount += stripped.removedCount;
+            if (stripped.entry !== null) {
+                preservedEntries.push(stripped.entry);
+            }
+        }
+        if (preservedEntries.length > 0) {
+            nextHooks[eventName] = preservedEntries;
+        }
+        else {
+            delete nextHooks[eventName];
+        }
+    }
+    if (removedCount === 0) {
+        return { nextContent: existingContent, removedCount: 0 };
+    }
+    if (Object.keys(nextHooks).length > 0) {
+        nextRoot.hooks = nextHooks;
+        return { nextContent: serializeCodexHooksConfig(nextRoot), removedCount };
+    }
+    delete nextRoot.hooks;
+    if (Object.keys(nextRoot).length > 0) {
+        return { nextContent: serializeCodexHooksConfig(nextRoot), removedCount };
+    }
+    return { nextContent: null, removedCount };
+}
+function findSectionBounds(lines, sectionHeader) {
+    const start = lines.findIndex((line) => line.trim() === sectionHeader);
+    if (start === -1) {
+        return null;
+    }
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index += 1) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[index])) {
+            end = index;
+            break;
+        }
+    }
+    return { start, end };
+}
+export function enableCodexHooksFeature(existing) {
+    const trimmed = existing.trimEnd();
+    const lines = trimmed ? trimmed.split(/\r?\n/) : [];
+    const section = findSectionBounds(lines, "[features]");
+    if (!section) {
+        return trimmed
+            ? `${trimmed}\n\n[features]\ncodex_hooks = true\n`
+            : "[features]\ncodex_hooks = true\n";
+    }
+    const featureLines = lines.slice(section.start + 1, section.end);
+    const existingIndex = featureLines.findIndex((line) => /^\s*codex_hooks\s*=/.test(line));
+    if (existingIndex !== -1) {
+        featureLines[existingIndex] = "codex_hooks = true";
+    }
+    else {
+        featureLines.push("codex_hooks = true");
+    }
+    const rebuilt = [
+        ...lines.slice(0, section.start + 1),
+        ...featureLines,
+        ...lines.slice(section.end)
+    ].join("\n");
+    return `${rebuilt.trimEnd()}\n`;
+}
+export function codexHooksEnabled(config) {
+    const lines = config.split(/\r?\n/);
+    const section = findSectionBounds(lines, "[features]");
+    if (!section) {
+        return false;
+    }
+    return lines
+        .slice(section.start + 1, section.end)
+        .some((line) => /^\s*codex_hooks\s*=\s*true\s*$/.test(line));
+}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+export * from "./codex-hooks.js";
 export * from "./prompt-aliases.js";
 export * from "./personas.js";
 export * from "./persona-router.js";
 export * from "./panel.js";
 export * from "./project-session.js";
+export * from "./question-obligations.js";

package/dist/index.js

@@ -1,5 +1,7 @@
+export * from "./codex-hooks.js";
 export * from "./prompt-aliases.js";
 export * from "./personas.js";
 export * from "./persona-router.js";
 export * from "./panel.js";
 export * from "./project-session.js";
+export * from "./question-obligations.js";

package/dist/longtable-codex-native-hook.d.ts

@@ -0,0 +1,4 @@
+type CodexHookPayload = Record<string, unknown>;
+export declare function dispatchCodexHook(payload: CodexHookPayload, cwdOverride?: string): Promise<Record<string, unknown> | null>;
+export declare function isCodexNativeHookMainModule(moduleUrl: string, argv1: string | undefined): boolean;
+export {};

package/dist/longtable-codex-native-hook.js

@@ -0,0 +1,314 @@
+import { pathToFileURL } from "node:url";
+import { loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
+function safeString(value) {
+    return typeof value === "string" ? value : "";
+}
+function safeInteger(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+        return Number.parseInt(value.trim(), 10);
+    }
+    return null;
+}
+function readHookEventName(payload) {
+    const candidate = safeString(payload.hook_event_name ??
+        payload.hookEventName ??
+        payload.event ??
+        payload.name).trim();
+    if (candidate === "SessionStart" ||
+        candidate === "PreToolUse" ||
+        candidate === "PostToolUse" ||
+        candidate === "UserPromptSubmit" ||
+        candidate === "Stop") {
+        return candidate;
+    }
+    return null;
+}
+function readPromptText(payload) {
+    return safeString(payload.prompt ?? payload.user_prompt ?? payload.userPrompt).trim();
+}
+function readToolName(payload) {
+    return safeString(payload.tool_name ?? payload.toolName).trim();
+}
+function readCommandText(payload) {
+    const direct = safeString(payload.command ?? payload.input ?? payload.tool_input ?? payload.toolInput).trim();
+    if (direct) {
+        return direct;
+    }
+    const toolInput = payload.tool_input ?? payload.toolInput;
+    if (toolInput && typeof toolInput === "object") {
+        const objectInput = toolInput;
+        return safeString(objectInput.command ?? objectInput.input ?? objectInput.cmd).trim();
+    }
+    return "";
+}
+function readExitCode(payload) {
+    return safeInteger(payload.exit_code ?? payload.exitCode);
+}
+function readCombinedOutput(payload) {
+    return [
+        safeString(payload.stderr),
+        safeString(payload.stdout),
+        safeString(payload.output)
+    ].filter(Boolean).join("\n").trim();
+}
+function formatQuestionOptions(question) {
+    const options = question.prompt.options.map((option) => option.value);
+    if (question.prompt.allowOther) {
+        options.push("other");
+    }
+    return options.join("/");
+}
+function pendingRequiredQuestions(state) {
+    return (state.questionLog ?? []).filter((question) => question.status === "pending" && question.prompt.required);
+}
+function pendingObligations(state) {
+    return pendingQuestionObligations(state);
+}
+function activeInterviewHook(state) {
+    return [...(state.hooks ?? [])].reverse().find((hook) => hook.kind === "longtable_interview" &&
+        (hook.status === "pending" || hook.status === "active" || hook.status === "ready_to_confirm"));
+}
+function buildAdditionalContextOutput(hookEventName, additionalContext) {
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            additionalContext
+        }
+    };
+}
+function buildBlockOutput(hookEventName, reason, additionalContext) {
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+            additionalContext
+        }
+    };
+}
+function buildStopBlockOutput(reason) {
+    return {
+        decision: "block",
+        reason
+    };
+}
+function looksLikeClosurePrompt(prompt) {
+    const normalized = prompt.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(final|finalize|commit|ship|submit|revise|rewrite|draft|publish|implement|fix)\b/i.test(normalized)
+        || /최종|확정|커밋|제출|수정|초안|구현|진행|고쳐/.test(normalized);
+}
+function isStateChangingBash(command) {
+    const normalized = command.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(git\s+commit|npm\s+version|mv|cp|rm|sed\s+-i|perl\s+-i|tee|touch|mkdir|rmdir|apply_patch|patch)\b/.test(normalized)
+        || />\s*\S+/.test(normalized);
+}
+async function loadLongTableRuntime(startPath) {
+    const context = await loadProjectContextFromDirectory(startPath);
+    if (!context) {
+        return null;
+    }
+    const state = await loadWorkspaceState(context);
+    return { context, state };
+}
+function buildWorkspaceSummary(runtime) {
+    const { context, state } = runtime;
+    const lines = [
+        "LongTable workspace detected.",
+        `Current goal: ${context.session.currentGoal}.`,
+        context.session.currentBlocker ? `Current blocker: ${context.session.currentBlocker}.` : "",
+        context.session.protectedDecision ? `Protected decision: ${context.session.protectedDecision}.` : "",
+        state.firstResearchShape ? `First research shape: ${state.firstResearchShape.handle}.` : "",
+        context.session.nextAction ? `Next action: ${context.session.nextAction}.` : ""
+    ].filter(Boolean);
+    return lines;
+}
+function buildPendingQuestionContext(question) {
+    return [
+        `Required Researcher Checkpoint is still pending: ${question.prompt.question}`,
+        `Options: ${formatQuestionOptions(question)}`,
+        `Record it with longtable decide --question ${question.id} --answer <value> if you are outside MCP elicitation.`
+    ].join("\n");
+}
+function buildPendingObligationContext(obligation) {
+    return [
+        `Pending LongTable research obligation: ${obligation.prompt}`,
+        obligation.reason,
+        obligation.questionId
+            ? `This obligation is linked to question ${obligation.questionId}; answer it before treating the direction as settled.`
+            : "Resume the LongTable interview and let it ask the next research-facing checkpoint before settling the direction."
+    ].join("\n");
+}
+function buildActiveInterviewContext(hook) {
+    const turnCount = hook.turns?.length ?? 0;
+    return [
+        "A LongTable interview is currently active.",
+        `Interview status: ${hook.status}.`,
+        `Turns recorded: ${turnCount}.`,
+        "Do not finalize the research direction until the interview is either summarized into a First Research Shape or explicitly cleared."
+    ].join("\n");
+}
+function sessionStartContext(runtime) {
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    const interview = activeInterviewHook(runtime.state);
+    const sections = [buildWorkspaceSummary(runtime).join("\n")];
+    if (blockingQuestion) {
+        sections.push(buildPendingQuestionContext(blockingQuestion));
+    }
+    else if (blockingObligation) {
+        sections.push(buildPendingObligationContext(blockingObligation));
+    }
+    else if (interview) {
+        sections.push(buildActiveInterviewContext(interview));
+    }
+    sections.push("Treat `.longtable/` state and `CURRENT.md` as the source of truth for this workspace.");
+    return sections.filter(Boolean).join("\n\n");
+}
+function userPromptSubmitContext(runtime, prompt) {
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    if (blockingQuestion) {
+        return buildPendingQuestionContext(blockingQuestion);
+    }
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    if (blockingObligation) {
+        return buildPendingObligationContext(blockingObligation);
+    }
+    const interview = activeInterviewHook(runtime.state);
+    if (interview) {
+        return buildActiveInterviewContext(interview);
+    }
+    if (runtime.context.session.protectedDecision && looksLikeClosurePrompt(prompt)) {
+        return [
+            `This workspace marks ${runtime.context.session.protectedDecision} as a protected decision.`,
+            "Before you settle it through drafting, revision, or closure, surface one researcher-facing checkpoint grounded in the current blocker or open questions."
+        ].join("\n");
+    }
+    return null;
+}
+function preToolUseOutput(runtime, payload) {
+    if (readToolName(payload) !== "Bash") {
+        return null;
+    }
+    const command = readCommandText(payload);
+    if (!isStateChangingBash(command)) {
+        return null;
+    }
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    if (blockingQuestion) {
+        return buildBlockOutput("PreToolUse", "A required LongTable checkpoint is still pending before a state-changing Bash command.", buildPendingQuestionContext(blockingQuestion));
+    }
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    if (blockingObligation) {
+        return buildBlockOutput("PreToolUse", "A LongTable research obligation is still pending before a state-changing Bash command.", buildPendingObligationContext(blockingObligation));
+    }
+    return null;
+}
+function postToolUseOutput(runtime, payload) {
+    if (readToolName(payload) !== "Bash") {
+        return null;
+    }
+    const command = readCommandText(payload);
+    const exitCode = readExitCode(payload);
+    const output = readCombinedOutput(payload);
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    if ((blockingQuestion || blockingObligation) && isStateChangingBash(command)) {
+        return buildBlockOutput("PostToolUse", "A state-changing Bash command completed while LongTable still had an unresolved checkpoint or obligation.", blockingQuestion
+            ? buildPendingQuestionContext(blockingQuestion)
+            : buildPendingObligationContext(blockingObligation));
+    }
+    if (exitCode !== null && exitCode !== 0 && output) {
+        return buildBlockOutput("PostToolUse", "The Bash command returned a non-zero exit code and should be reviewed before LongTable continues.", "Review the command output and explain what failed before retrying or continuing.");
+    }
+    return null;
+}
+function stopOutput(runtime) {
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    if (blockingQuestion) {
+        return buildStopBlockOutput("A required LongTable Researcher Checkpoint is still pending.");
+    }
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    if (blockingObligation) {
+        return buildStopBlockOutput("A LongTable research obligation is still pending.");
+    }
+    const interview = activeInterviewHook(runtime.state);
+    if (interview) {
+        return buildStopBlockOutput("A LongTable interview is still active and should not be closed silently.");
+    }
+    return null;
+}
+export async function dispatchCodexHook(payload, cwdOverride) {
+    const hookEventName = readHookEventName(payload);
+    if (!hookEventName) {
+        return null;
+    }
+    const runtime = await loadLongTableRuntime(cwdOverride ?? process.cwd());
+    if (!runtime) {
+        return null;
+    }
+    if (hookEventName === "SessionStart") {
+        return buildAdditionalContextOutput(hookEventName, sessionStartContext(runtime));
+    }
+    if (hookEventName === "UserPromptSubmit") {
+        const additionalContext = userPromptSubmitContext(runtime, readPromptText(payload));
+        return additionalContext
+            ? buildAdditionalContextOutput(hookEventName, additionalContext)
+            : null;
+    }
+    if (hookEventName === "PreToolUse") {
+        return preToolUseOutput(runtime, payload);
+    }
+    if (hookEventName === "PostToolUse") {
+        return postToolUseOutput(runtime, payload);
+    }
+    if (hookEventName === "Stop") {
+        return stopOutput(runtime);
+    }
+    return null;
+}
+async function readStdinJson() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function isCodexNativeHookMainModule(moduleUrl, argv1) {
+    if (!argv1) {
+        return false;
+    }
+    return moduleUrl === pathToFileURL(argv1).href;
+}
+async function main() {
+    const payload = await readStdinJson();
+    const output = await dispatchCodexHook(payload);
+    if (output) {
+        process.stdout.write(JSON.stringify(output));
+    }
+}
+if (isCodexNativeHookMainModule(import.meta.url, process.argv[1])) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    });
+}