@longtable/cli 0.1.32 → 0.1.33

package/dist/cli.js

@@ -6,6 +6,7 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output, cwd, env, exit } from "node:process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
 import { assessSearchSourceCapabilities, buildResearchSearchIntent, buildSearchCapabilitySnapshot, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, searchCapabilitySnapshotPath, summarizeConfiguredPublisherAccess } from "./search/index.js";
 import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupOutput, saveSetupAndRuntimeConfig, serializeSetupOutput, writeRuntimeConfig } from "@longtable/setup";
@@ -15,7 +16,8 @@ import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodex
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
-import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
+import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, mergeManagedCodexHooksConfig, removeManagedCodexHooks } from "./codex-hooks.js";
+import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 import { buildTeamDebate, buildTeamReview, renderTeamDebateSummary } from "./debate.js";
 import { createPromptRenderer } from "./prompt-renderer.js";
 const VALID_MODES = new Set([
@@ -43,7 +45,7 @@ const ANSI = {
     green: "\u001B[32m"
 };
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
-const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.32";
+const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.33";
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {
@@ -97,8 +99,8 @@ function usage() {
         "  longtable init [deprecated alias for setup; full legacy flags still supported for automation]",
         "  longtable start [deprecated fallback] [--path <dir>] [--name <project>] [--goal <text>] [--blocker <text>] [--research-object research_question|theory_framework|measurement_instrument|study_design|analysis_plan|manuscript] [--gap-risk known_gap|suspected_tacit_assumptions|diagnose] [--protected-decision theory|measurement|method|evidence_citation|authorship_voice|submission_public_sharing] [--perspectives <role[,role]>] [--disagreement synthesis_only|show_on_conflict|always_visible] [--setup <path>] [--json] [--no-interview]",
         "  longtable resume [--cwd <path>] [--json]",
-        "  longtable doctor [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
-        "  longtable status [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
+        "  longtable doctor [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
+        "  longtable status [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
         "  longtable roles [--json]",
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
@@ -112,6 +114,7 @@ function usage() {
         "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable clarify --prompt <task-context> [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json] [--force]",
         "  longtable question --prompt <decision-context> [--title <text>] [--text <question>] [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json]",
+        "  longtable clear-question --question <id> --reason <text> [--cwd <path>] [--json]",
         "  longtable panel [--prompt <text>] [--role <role[,role]>] [--mode review|critique|draft|commit] [--visibility synthesis_only|show_on_conflict|always_visible] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable decide [--question <id>] --answer <value-or-text> [--rationale <text>] [--provider codex|claude] [--cwd <path>] [--json]",
         "  longtable explore|review|critique|draft|commit|submit [--prompt <text>] [--role <role[,role]>] [--panel] [--show-conflicts] [--show-deliberation] [--print] [--json] [--stage <stage>] [--setup <path>] [--cwd <path>]",
@@ -120,7 +123,9 @@ function usage() {
         "  longtable codex remove-skills [--dir <path>]",
         "  longtable codex install-prompts [--dir <path>]",
         "  longtable codex remove-prompts [--dir <path>]",
-        "  longtable codex status [--dir <path>] [--json]",
+        "  longtable codex install-hooks [--codex-config <path>] [--hooks-path <path>] [--json]",
+        "  longtable codex remove-hooks [--codex-config <path>] [--hooks-path <path>] [--json]",
+        "  longtable codex status [--dir <path>] [--codex-config <path>] [--hooks-path <path>] [--json]",
         "  longtable claude install-skills [--dir <path>]",
         "  longtable claude remove-skills [--dir <path>]",
         "  longtable claude status [--dir <path>] [--json]",
@@ -144,7 +149,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "panel", "decide", "sentinel", "team", "search"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "panel", "decide", "sentinel", "team", "search"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -1113,6 +1118,16 @@ function resolveCodexMcpConfigPath(args) {
         ? args["codex-config"].trim()
         : "~/.codex/config.toml"));
 }
+function resolveCodexHooksPath(args) {
+    if (typeof args["hooks-path"] === "string" && args["hooks-path"].trim()) {
+        return resolve(normalizeUserPath(args["hooks-path"]));
+    }
+    const configPath = resolveCodexMcpConfigPath(args);
+    return resolve(dirname(configPath), "hooks.json");
+}
+function resolveCliPackageRoot() {
+    return resolve(fileURLToPath(new URL("..", import.meta.url)));
+}
 function resolveClaudeMcpSettingsPath(args) {
     return resolve(normalizeUserPath(typeof args["claude-settings"] === "string" && args["claude-settings"].trim()
         ? args["claude-settings"].trim()
@@ -1195,6 +1210,56 @@ async function writeClaudeMcpSettings(path, serverName, command, mcpArgs) {
     await writeFile(path, `${updated}\n`, "utf8");
     return `${updated}\n`;
 }
+async function installCodexNativeHooks(args) {
+    const configPath = resolveCodexMcpConfigPath(args);
+    const hooksPath = resolveCodexHooksPath(args);
+    const packageRoot = resolveCliPackageRoot();
+    const existingConfig = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
+    const existingHooks = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
+    const nextConfig = enableCodexHooksFeature(existingConfig);
+    const nextHooks = mergeManagedCodexHooksConfig(existingHooks, packageRoot);
+    await mkdir(dirname(configPath), { recursive: true });
+    await mkdir(dirname(hooksPath), { recursive: true });
+    await writeFile(configPath, nextConfig, "utf8");
+    await writeFile(hooksPath, nextHooks, "utf8");
+    return {
+        configPath,
+        hooksPath,
+        codexHooksEnabled: codexHooksEnabled(nextConfig),
+        managedEvents: [...LONGTABLE_MANAGED_HOOK_EVENTS],
+        write: true
+    };
+}
+async function removeCodexNativeHooks(args) {
+    const configPath = resolveCodexMcpConfigPath(args);
+    const hooksPath = resolveCodexHooksPath(args);
+    const existingHooks = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
+    const removed = existingHooks ? removeManagedCodexHooks(existingHooks) : { nextContent: null, removedCount: 0 };
+    if (removed.nextContent === null) {
+        await rm(hooksPath, { force: true });
+    }
+    else {
+        await mkdir(dirname(hooksPath), { recursive: true });
+        await writeFile(hooksPath, removed.nextContent, "utf8");
+    }
+    const configContent = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
+    return {
+        configPath,
+        hooksPath,
+        codexHooksEnabled: codexHooksEnabled(configContent),
+        managedEvents: removed.removedCount > 0 ? [...LONGTABLE_MANAGED_HOOK_EVENTS] : [],
+        write: true
+    };
+}
+function renderCodexHookInstallSummary(result) {
+    return [
+        "LongTable Codex hooks",
+        `- config: ${result.configPath}`,
+        `- hooks: ${result.hooksPath}`,
+        `- codex_hooks feature: ${result.codexHooksEnabled ? "enabled" : "missing"}`,
+        `- managed events: ${result.managedEvents.length > 0 ? result.managedEvents.join(", ") : "none"}`
+    ].join("\n");
+}
 function renderMcpInstallSummary(result) {
     const lines = [
         "LongTable MCP transport",
@@ -1381,6 +1446,13 @@ async function collectDoctorStatus(args) {
     const codexMcpConfig = existsSync(codexMcpConfigPath)
         ? await readFile(codexMcpConfigPath, "utf8")
         : "";
+    const codexHooksPath = resolveCodexHooksPath(args);
+    const codexHooksContent = existsSync(codexHooksPath)
+        ? await readFile(codexHooksPath, "utf8")
+        : "";
+    const missingManagedHookEvents = codexHooksContent
+        ? (getMissingManagedCodexHookEvents(codexHooksContent) ?? [...LONGTABLE_MANAGED_HOOK_EVENTS])
+        : [...LONGTABLE_MANAGED_HOOK_EVENTS];
     const expectedCodexSkills = buildCodexSkillSpecs(roles).map((skill) => skill.name);
     const expectedClaudeSkills = buildClaudeSkillSpecs(roles).map((skill) => skill.name);
     const [codexSkills, claudeSkills, codexAliases, workspace] = await Promise.all([
@@ -1409,7 +1481,11 @@ async function collectDoctorStatus(args) {
                 mcpConfigPath: codexMcpConfigPath,
                 mcpConfigExists: existsSync(codexMcpConfigPath),
                 longtableMcpConfigured: codexLongTableMcpConfigured(codexMcpConfig),
-                mcpElicitationsAllowed: codexMcpElicitationsAllowed(codexMcpConfig)
+                mcpElicitationsAllowed: codexMcpElicitationsAllowed(codexMcpConfig),
+                hooksPath: codexHooksPath,
+                hooksExists: existsSync(codexHooksPath),
+                codexHooksEnabled: codexHooksEnabled(codexMcpConfig),
+                missingManagedHookEvents
             },
             claude: {
                 command: "claude",
@@ -1451,6 +1527,9 @@ function renderDoctorStatus(status) {
         `- MCP config: ${status.providers.codex.mcpConfigExists ? "present" : "missing"} (${status.providers.codex.mcpConfigPath})`,
         `- LongTable MCP: ${status.providers.codex.longtableMcpConfigured ? "configured" : "missing"}`,
         `- MCP elicitation approval: ${status.providers.codex.mcpElicitationsAllowed ? "allowed" : "not allowed"}`,
+        `- Codex hooks file: ${status.providers.codex.hooksExists ? "present" : "missing"} (${status.providers.codex.hooksPath})`,
+        `- codex_hooks feature: ${status.providers.codex.codexHooksEnabled ? "enabled" : "missing"}`,
+        `- managed hook coverage: ${status.providers.codex.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.providers.codex.missingManagedHookEvents.join(", ")}`}`,
         "",
         ...renderProviderDoctorBlock("Claude", status.providers.claude),
         "",
@@ -1461,7 +1540,7 @@ function renderDoctorStatus(status) {
     }
     else {
         const workspace = status.workspace;
-        lines.push(`- project: ${workspace.project?.name ?? "unknown"}`, `- root: ${workspace.rootPath ?? "unknown"}`, `- goal: ${workspace.session?.currentGoal ?? "unknown"}`, `- invocations: ${workspace.counts?.invocations ?? 0}`, `- questions: ${workspace.counts?.questions ?? 0} (${workspace.counts?.pendingQuestions ?? 0} pending, ${workspace.counts?.answeredQuestions ?? 0} answered)`, `- decisions: ${workspace.counts?.decisions ?? 0}`);
+        lines.push(`- project: ${workspace.project?.name ?? "unknown"}`, `- root: ${workspace.rootPath ?? "unknown"}`, `- goal: ${workspace.session?.currentGoal ?? "unknown"}`, `- invocations: ${workspace.counts?.invocations ?? 0}`, `- questions: ${workspace.counts?.questions ?? 0} (${workspace.counts?.pendingQuestions ?? 0} pending, ${workspace.counts?.answeredQuestions ?? 0} answered)`, `- obligations: ${workspace.counts?.pendingObligations ?? 0} pending`, `- decisions: ${workspace.counts?.decisions ?? 0}`);
         if ((workspace.recentInvocations ?? []).length > 0) {
             lines.push("- recent invocations:");
             for (const invocation of workspace.recentInvocations ?? []) {
@@ -1475,6 +1554,12 @@ function renderDoctorStatus(status) {
                 lines.push(`  - ${question.id}: ${question.question} (${question.options.join("/")})`);
             }
         }
+        if ((workspace.pendingObligations ?? []).length > 0) {
+            lines.push("- pending obligations:");
+            for (const obligation of workspace.pendingObligations ?? []) {
+                lines.push(`  - ${obligation.id}: ${obligation.prompt}`);
+            }
+        }
         if ((workspace.answerWarnings ?? []).length > 0) {
             lines.push("- answer warnings:");
             for (const warning of workspace.answerWarnings ?? []) {
@@ -1489,11 +1574,16 @@ function renderDoctorStatus(status) {
     const canFix = status.providers.codex.missingSkills.length > 0 ||
         status.providers.claude.missingSkills.length > 0 ||
         status.providers.codex.legacyPromptFilesInstalled.length > 0 ||
+        !status.providers.codex.codexHooksEnabled ||
+        status.providers.codex.missingManagedHookEvents.length > 0 ||
         (status.setupExists &&
             (!status.providers.codex.runtimeExists || !status.providers.claude.runtimeExists));
     if (canFix) {
         nextActions.push("longtable doctor --fix");
     }
+    if (!status.providers.codex.codexHooksEnabled || status.providers.codex.missingManagedHookEvents.length > 0) {
+        nextActions.push("longtable codex install-hooks");
+    }
     if (!status.setupExists) {
         nextActions.push("longtable setup --provider codex");
     }
@@ -1523,6 +1613,15 @@ function renderRepairSummary(repair) {
     if (repair.removedLegacyPromptFiles.length > 0) {
         lines.push(`- removed legacy prompt files: ${repair.removedLegacyPromptFiles.length}`);
     }
+    if (repair.installedCodexHooks) {
+        lines.push("- installed Codex native hooks");
+    }
+    if ((repair.repairedWorkspaceState ?? []).length > 0) {
+        lines.push("- repaired workspace state:");
+        for (const item of repair.repairedWorkspaceState ?? []) {
+            lines.push(`  - ${item}`);
+        }
+    }
     if (repair.writtenRuntimeConfigs.length > 0) {
         lines.push("- wrote runtime configs:");
         for (const target of repair.writtenRuntimeConfigs) {
@@ -1574,6 +1673,8 @@ async function repairDoctorStatus(args, status) {
         installedCodexSkills: [],
         installedClaudeSkills: [],
         removedLegacyPromptFiles: [],
+        installedCodexHooks: false,
+        repairedWorkspaceState: [],
         writtenRuntimeConfigs: [],
         skipped: []
     };
@@ -1586,8 +1687,16 @@ async function repairDoctorStatus(args, status) {
     if (status.providers.codex.legacyPromptFilesInstalled.length > 0) {
         repair.removedLegacyPromptFiles = await removeCodexPromptAliases(codexPromptsDir);
     }
+    if (!status.providers.codex.codexHooksEnabled || status.providers.codex.missingManagedHookEvents.length > 0) {
+        await installCodexNativeHooks(args);
+        repair.installedCodexHooks = true;
+    }
     if (!status.setupExists) {
         repair.skipped.push("runtime configs require setup approval; run `longtable setup --provider codex` first");
+        const workspaceContext = await loadProjectContextFromDirectory(typeof args.cwd === "string" ? args.cwd : cwd());
+        if (workspaceContext) {
+            repair.repairedWorkspaceState = (await repairWorkspaceStateConsistency({ context: workspaceContext })).repaired;
+        }
         return repair;
     }
     const setup = await loadSetupOutput(setupOverride);
@@ -1607,6 +1716,10 @@ async function repairDoctorStatus(args, status) {
             format: target.format
         });
     }
+    const workspaceContext = await loadProjectContextFromDirectory(typeof args.cwd === "string" ? args.cwd : cwd());
+    if (workspaceContext) {
+        repair.repairedWorkspaceState = (await repairWorkspaceStateConsistency({ context: workspaceContext })).repaired;
+    }
     return repair;
 }
 async function runDoctor(args) {
@@ -2331,6 +2444,41 @@ async function runQuestion(args) {
     console.log(`- answer: longtable decide --question ${result.question.id} --answer <value>`);
     console.log(`- current: ${context.currentFilePath}`);
 }
+async function runClearQuestion(args) {
+    const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const questionId = typeof args.question === "string" ? args.question.trim() : "";
+    const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+    if (!questionId) {
+        throw new Error("`clear-question` requires --question <id>.");
+    }
+    if (!reason) {
+        throw new Error("`clear-question` requires --reason <text>.");
+    }
+    const context = await loadProjectContextFromDirectory(workingDirectory);
+    if (!context) {
+        throw new Error("No LongTable project workspace was found here. Run this inside a project or pass --cwd.");
+    }
+    const result = await clearWorkspaceQuestion({
+        context,
+        questionId,
+        reason
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            question: result.question,
+            files: {
+                state: context.stateFilePath,
+                current: context.currentFilePath
+            }
+        }, null, 2));
+        return;
+    }
+    console.log("LongTable question cleared");
+    console.log(`- question: ${result.question.id}`);
+    console.log(`- reason: ${result.question.clearedReason ?? reason}`);
+    console.log(`- state: ${context.stateFilePath}`);
+    console.log(`- current: ${context.currentFilePath}`);
+}
 function isInteractiveTerminal() {
     return Boolean(input.isTTY && output.isTTY);
 }
@@ -2933,11 +3081,34 @@ async function runCodexSubcommand(subcommand, args) {
         console.log(`Removed ${removed.length} legacy LongTable prompt files from ${resolveCodexPromptsDir(customDir)}`);
         return;
     }
+    if (subcommand === "install-hooks") {
+        const result = await installCodexNativeHooks(args);
+        if (args.json === true) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(renderCodexHookInstallSummary(result));
+        console.log("Restart Codex so the native hook config is reloaded.");
+        return;
+    }
+    if (subcommand === "remove-hooks") {
+        const result = await removeCodexNativeHooks(args);
+        if (args.json === true) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(renderCodexHookInstallSummary(result));
+        return;
+    }
     if (subcommand === "status") {
         const aliases = await listInstalledCodexPromptAliases(customDir);
         const skills = await listInstalledCodexSkills(roles, customDir);
         const setupPath = resolveDefaultSetupPath(typeof args.path === "string" ? args.path : undefined).path;
         const runtimePath = resolveDefaultRuntimeConfigPath("codex", typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined).path;
+        const configPath = resolveCodexMcpConfigPath(args);
+        const configContent = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
+        const hooksPath = resolveCodexHooksPath(args);
+        const hooksContent = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
         const status = {
             setupPath,
             setupExists: existsSync(setupPath),
@@ -2946,7 +3117,14 @@ async function runCodexSubcommand(subcommand, args) {
             skillsDir: resolveCodexSkillsDir(customDir),
             skillsInstalled: skills.map((skill) => skill.name),
             promptsDir: resolveCodexPromptsDir(customDir),
-            legacyPromptFilesInstalled: aliases.map((alias) => alias.name)
+            legacyPromptFilesInstalled: aliases.map((alias) => alias.name),
+            codexConfigPath: configPath,
+            codexHooksEnabled: codexHooksEnabled(configContent),
+            hooksPath,
+            hooksExists: existsSync(hooksPath),
+            missingManagedHookEvents: hooksContent
+                ? (getMissingManagedCodexHookEvents(hooksContent) ?? [...LONGTABLE_MANAGED_HOOK_EVENTS])
+                : [...LONGTABLE_MANAGED_HOOK_EVENTS]
         };
         if (args.json === true) {
             console.log(JSON.stringify(status, null, 2));
@@ -2976,6 +3154,10 @@ async function runCodexSubcommand(subcommand, args) {
                 console.log(`  - ${alias.name}`);
             }
         }
+        console.log(`- codex config: ${status.codexConfigPath}`);
+        console.log(`- codex_hooks feature: ${status.codexHooksEnabled ? "enabled" : "missing"}`);
+        console.log(`- hooks file: ${status.hooksExists ? "present" : "missing"} (${status.hooksPath})`);
+        console.log(`- managed hook coverage: ${status.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.missingManagedHookEvents.join(", ")}`}`);
         return;
     }
     throw new Error("Unknown codex subcommand.");
@@ -3089,6 +3271,10 @@ async function main() {
         await runQuestion(values);
         return;
     }
+    if (command === "clear-question") {
+        await runClearQuestion(values);
+        return;
+    }
     if (command === "panel") {
         await runPanelCommand(values);
         return;

package/dist/codex-hooks.d.ts

@@ -0,0 +1,22 @@
+export declare const LONGTABLE_MANAGED_HOOK_EVENTS: readonly ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"];
+type ManagedHookEventName = (typeof LONGTABLE_MANAGED_HOOK_EVENTS)[number];
+type JsonObject = Record<string, unknown>;
+export interface ManagedCodexHooksConfig {
+    hooks: Record<ManagedHookEventName, Array<Record<string, unknown>>>;
+}
+interface ParsedCodexHooksConfig {
+    root: JsonObject;
+    hooks: JsonObject;
+}
+export interface RemoveManagedCodexHooksResult {
+    nextContent: string | null;
+    removedCount: number;
+}
+export declare function buildManagedCodexHooksConfig(packageRoot: string): ManagedCodexHooksConfig;
+export declare function parseCodexHooksConfig(content: string): ParsedCodexHooksConfig | null;
+export declare function getMissingManagedCodexHookEvents(content: string): ManagedHookEventName[] | null;
+export declare function mergeManagedCodexHooksConfig(existingContent: string | null | undefined, packageRoot: string): string;
+export declare function removeManagedCodexHooks(existingContent: string): RemoveManagedCodexHooksResult;
+export declare function enableCodexHooksFeature(existing: string): string;
+export declare function codexHooksEnabled(config: string): boolean;
+export {};

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 {};