throughline 0.10.2 → 0.10.5

package/src/cli/install.mjs

@@ -11,6 +11,7 @@
  * script path で登録する。
  * Grok-facing hook も Desktop の GUI PATH に throughline が無いため、同じ絶対
  * node + CLI script path で ~/.grok/hooks/throughline.json に書く。
+ * Cursor-facing hook は ~/.cursor/hooks.json へ upsert する（工場 hook は残す）。
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, unlinkSync, rmSync, realpathSync } from 'node:fs';
@@ -27,6 +28,7 @@ const CODEX_SKILL_NAMES = ['throughline'];
 const CODEX_HOOKS_RELATIVE_PATH = ['.codex', 'hooks.json'];
 const CODEX_CONFIG_RELATIVE_PATH = ['.codex', 'config.toml'];
 const GROK_HOOKS_RELATIVE_PATH = ['.grok', 'hooks', 'throughline.json'];
+const CURSOR_HOOKS_RELATIVE_PATH = ['.cursor', 'hooks.json'];
 
 // Throughline が管理する hook コマンド一覧
 // schema v4 以降: PostToolUse (capture-tool) は廃止。Stop 内で L2/L3 を一括処理する。
@@ -297,6 +299,16 @@ export function buildGrokHookCommand(subcommand, {
   return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} ${subcommand}`;
 }
 
+export function buildCursorHookCommand(subcommand, options = {}) {
+  return buildGrokHookCommand(subcommand, options);
+}
+
+export function isThroughlineCursorHookCommand(command) {
+  return typeof command === 'string'
+    && command.includes('throughline.mjs')
+    && /\b(session-start|prompt-submit|process-turn)\b/.test(command);
+}
+
 export function createGrokHooksFile(options = {}) {
   return {
     hooks: {
@@ -334,6 +346,74 @@ function uninstallGrokHooks() {
   return { hooksPath, removed: 1 };
 }
 
+function resolveCursorHooksPath() {
+  return join(homedir(), ...CURSOR_HOOKS_RELATIVE_PATH);
+}
+
+export function createCursorHookEntries(options = {}) {
+  return {
+    sessionStart: [
+      { command: buildCursorHookCommand('session-start', options), timeout: 10 },
+    ],
+    beforeSubmitPrompt: [
+      { command: buildCursorHookCommand('prompt-submit', options), timeout: 30 },
+    ],
+    stop: [
+      { command: buildCursorHookCommand('process-turn', options), timeout: 300 },
+    ],
+  };
+}
+
+function readCursorHooksFile(hooksPath) {
+  if (!existsSync(hooksPath)) return { version: 1, hooks: {} };
+  const parsed = JSON.parse(readFileSync(hooksPath, 'utf8'));
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`${hooksPath} は object である必要があります`);
+  }
+  if (parsed.hooks == null) parsed.hooks = {};
+  if (typeof parsed.hooks !== 'object' || Array.isArray(parsed.hooks)) {
+    throw new Error(`${hooksPath} の hooks は object である必要があります`);
+  }
+  return parsed;
+}
+
+function installCursorHooks() {
+  const hooksPath = resolveCursorHooksPath();
+  mkdirSync(dirname(hooksPath), { recursive: true });
+  const current = readCursorHooksFile(hooksPath);
+  current.version = 1;
+  const wanted = createCursorHookEntries();
+  for (const [event, entries] of Object.entries(wanted)) {
+    const existing = Array.isArray(current.hooks[event]) ? current.hooks[event] : [];
+    const kept = existing.filter((entry) => !isThroughlineCursorHookCommand(entry?.command));
+    current.hooks[event] = [...kept, ...entries];
+  }
+  writeFileSync(hooksPath, `${JSON.stringify(current, null, 2)}\n`);
+  return { hooksPath };
+}
+
+function uninstallCursorHooks() {
+  const hooksPath = resolveCursorHooksPath();
+  if (!existsSync(hooksPath)) return { hooksPath, removed: 0 };
+  const current = readCursorHooksFile(hooksPath);
+  let removed = 0;
+  for (const [event, list] of Object.entries(current.hooks ?? {})) {
+    if (!Array.isArray(list)) continue;
+    const kept = list.filter((entry) => {
+      if (isThroughlineCursorHookCommand(entry?.command)) {
+        removed += 1;
+        return false;
+      }
+      return true;
+    });
+    if (kept.length > 0) current.hooks[event] = kept;
+    else delete current.hooks[event];
+  }
+  if (removed === 0) return { hooksPath, removed: 0 };
+  writeFileSync(hooksPath, `${JSON.stringify(current, null, 2)}\n`);
+  return { hooksPath, removed };
+}
+
 function installSlashCommands(commandsDir) {
   if (!existsSync(SLASH_COMMANDS_SRC)) {
     return { installed: [], skipped: 'source-missing' };
@@ -589,6 +669,7 @@ export async function run(args = []) {
     const removedCommands = uninstallSlashCommands(commandsDir);
     const codex = args.includes('--project') ? null : uninstallCodexHooks();
     const grok = args.includes('--project') ? null : uninstallGrokHooks();
+    const cursor = args.includes('--project') ? null : uninstallCursorHooks();
     const removedCodexSkills = args.includes('--project') ? [] : uninstallCodexSkills(codexSkillsDir);
     console.log('Throughline hooks を削除しました。');
     console.log(`  ${settingsPath}`);
@@ -601,6 +682,9 @@ export async function run(args = []) {
     if (grok?.removed > 0) {
       console.log(`  Grok hooks 削除: ${grok.removed} (${grok.hooksPath})`);
     }
+    if (cursor?.removed > 0) {
+      console.log(`  Cursor hooks 削除: ${cursor.removed} (${cursor.hooksPath})`);
+    }
     if (removedCodexSkills.length > 0) {
       console.log(`  Codex skills 削除: ${removedCodexSkills.join(', ')} (${codexSkillsDir})`);
     }
@@ -624,6 +708,7 @@ export async function run(args = []) {
   const { installed: installedCommands, skipped } = installSlashCommands(commandsDir);
   const codex = args.includes('--project') ? null : installCodexHooks();
   const grok = args.includes('--project') ? null : installGrokHooks();
+  const cursor = args.includes('--project') ? null : installCursorHooks();
   const codexSkills = args.includes('--project') ? { installed: [], skipped: null } : installCodexSkills(codexSkillsDir);
   const monitorTask = ensureMonitorTaskFile({
     cwd: process.cwd(),
@@ -643,6 +728,9 @@ export async function run(args = []) {
   if (grok) {
     console.log(`  ${grok.hooksPath}`);
   }
+  if (cursor) {
+    console.log(`  ${cursor.hooksPath}`);
+  }
   console.log('');
   console.log('有効な hooks:');
   console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
@@ -656,6 +744,9 @@ export async function run(args = []) {
   if (grok) {
     console.log('  Grok SessionStart / UserPromptSubmit / Stop → ~/.grok/hooks/throughline.json');
   }
+  if (cursor) {
+    console.log('  Cursor sessionStart / beforeSubmitPrompt / stop → ~/.cursor/hooks.json（工場hookは残す）');
+  }
   console.log('');
   if (installedCommands.length > 0) {
     console.log(`slash commands を配置しました: ${installedCommands.map(n => '/' + n.replace(/\.md$/, '')).join(', ')}`);

package/src/cli/install.test.mjs

@@ -10,8 +10,10 @@ import {
   buildCodexUserPromptSubmitHookCommand,
   buildGrokHookCommand,
   createGrokHooksFile,
+  createCursorHookEntries,
   isEquivalentCodexHookCommand,
   isThroughlineCodexHookCommand,
+  isThroughlineCursorHookCommand,
   parseCodexHookCommand,
   resolveCodexHookNodePath,
   run,
@@ -92,6 +94,28 @@ test('global install copies Throughline slash commands to ~/.claude/commands/',
       assert.match(command, /throughline\.mjs/);
       assert.doesNotMatch(command, /^throughline /);
     }
+    const cursorHooks = JSON.parse(readFileSync(join(home.dir, '.cursor', 'hooks.json'), 'utf8'));
+    assert.equal(cursorHooks.version, 1);
+    assert.equal(
+      cursorHooks.hooks.sessionStart[0].command,
+      createCursorHookEntries().sessionStart[0].command,
+    );
+    assert.equal(
+      cursorHooks.hooks.beforeSubmitPrompt[0].command,
+      createCursorHookEntries().beforeSubmitPrompt[0].command,
+    );
+    assert.equal(
+      cursorHooks.hooks.stop[0].command,
+      createCursorHookEntries().stop[0].command,
+    );
+    for (const command of [
+      cursorHooks.hooks.sessionStart[0].command,
+      cursorHooks.hooks.beforeSubmitPrompt[0].command,
+      cursorHooks.hooks.stop[0].command,
+    ]) {
+      assert.equal(isThroughlineCursorHookCommand(command), true);
+      assert.doesNotMatch(command, /^throughline /);
+    }
   } finally {
     unsilence();
     home.restore();
@@ -192,6 +216,39 @@ test('Grok hook commands are absolute node + throughline.mjs on every platform',
   assert.equal(file.hooks.Stop[0].hooks[0].async, true);
 });
 
+test('Cursor install upserts product hooks and keeps factory commands', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const unsilence = silence();
+  try {
+    mkdirSync(join(home.dir, '.cursor'), { recursive: true });
+    writeFileSync(join(home.dir, '.cursor', 'hooks.json'), `${JSON.stringify({
+      version: 1,
+      hooks: {
+        sessionStart: [{ command: '/tmp/cursor-todo-gate-hook session-start', timeout: 10 }],
+      },
+    }, null, 2)}\n`);
+    await run([]);
+    const installed = JSON.parse(readFileSync(join(home.dir, '.cursor', 'hooks.json'), 'utf8'));
+    assert.equal(installed.hooks.sessionStart[0].command, '/tmp/cursor-todo-gate-hook session-start');
+    assert.equal(isThroughlineCursorHookCommand(installed.hooks.sessionStart[1].command), true);
+    assert.equal(isThroughlineCursorHookCommand(installed.hooks.beforeSubmitPrompt[0].command), true);
+    assert.equal(isThroughlineCursorHookCommand(installed.hooks.stop[0].command), true);
+    await run(['--uninstall']);
+    const after = JSON.parse(readFileSync(join(home.dir, '.cursor', 'hooks.json'), 'utf8'));
+    assert.equal(after.hooks.sessionStart.length, 1);
+    assert.equal(after.hooks.sessionStart[0].command, '/tmp/cursor-todo-gate-hook session-start');
+    assert.equal(after.hooks.beforeSubmitPrompt, undefined);
+    assert.equal(after.hooks.stop, undefined);
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
 test('Codex hook builders use the PowerShell call operator on Windows only', () => {
   const options = {
     nodePath: String.raw`C:\Program Files\nodejs\node.exe`,

package/src/cli/runtime-errors.mjs

@@ -5,13 +5,14 @@ import {
   readRuntimeErrorSnapshot,
   reopenRuntimeError,
   resolveRuntimeError,
+  setRuntimeErrorCollectionEnabled,
 } from '../runtime-error-store.mjs';
 
-const USAGE = 'usage: throughline runtime-errors <snapshot|diagnostics|ack|resolve|reopen|compact> [arguments] --json';
+const USAGE = 'usage: throughline runtime-errors <enable|disable|snapshot|diagnostics|ack|resolve|reopen|compact> [arguments] --json';
 
 export function parseArgs(argv = []) {
   const command = argv[0];
-  if (!['snapshot', 'diagnostics', 'ack', 'resolve', 'reopen', 'compact'].includes(command)) {
+  if (!['enable', 'disable', 'snapshot', 'diagnostics', 'ack', 'resolve', 'reopen', 'compact'].includes(command)) {
     throw new TypeError(USAGE);
   }
   const options = { command, json: false, afterCursor: 0, limit: 256, value: null };
@@ -47,7 +48,12 @@ export function run(argv = [], dependencies = {}) {
   try {
     const env = dependencies.env ?? process.env;
     let result;
-    if (options.command === 'snapshot') {
+    if (options.command === 'enable' || options.command === 'disable') {
+      result = (dependencies.configure ?? setRuntimeErrorCollectionEnabled)(
+        options.command === 'enable',
+        { env },
+      );
+    } else if (options.command === 'snapshot') {
       result = (dependencies.readSnapshot ?? readRuntimeErrorSnapshot)({
         env,
         afterCursor: options.afterCursor,

package/src/cli/runtime-errors.test.mjs

@@ -1,16 +1,16 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { parseArgs, run } from './runtime-errors.mjs';
-import { defaultFactoryReporterConfigPath } from '../runtime-error-store.mjs';
-import { applyWindowsPrivateAcl } from '../os/windows-acl-test-helper.mjs';
 
 test('runtime-errors CLI: strict command surface accepts no raw payload options', () => {
+  assert.equal(parseArgs(['enable', '--json']).command, 'enable');
+  assert.equal(parseArgs(['disable', '--json']).command, 'disable');
   assert.deepEqual(parseArgs(['snapshot', '--after-cursor', '2', '--limit', '3', '--json']), {
     command: 'snapshot', json: true, afterCursor: 2, limit: 3, value: null,
   });
@@ -52,16 +52,16 @@ test('runtime-errors CLI: snapshot and diagnostics are JSON-only and contain no
     XDG_CONFIG_HOME: join(root, 'config'),
     XDG_STATE_HOME: join(root, 'state'),
   };
-  const configPath = defaultFactoryReporterConfigPath(env);
-  mkdirSync(dirname(configPath), { recursive: true });
-  writeFileSync(configPath, JSON.stringify({
-    schema_version: '1.0',
-    host: { id: 'test-host', profile: process.platform === 'win32' ? 'windows-native' : 'mac' },
-    collection: { enabled: true },
-    reporting: { enabled: false },
-  }));
-  applyWindowsPrivateAcl(configPath);
   const bin = new URL('../../bin/throughline.mjs', import.meta.url);
+  const enabled = spawnSync(process.execPath, [fileURLToPath(bin), 'runtime-errors', 'enable', '--json'], {
+    env,
+    encoding: 'utf8',
+  });
+  assert.equal(enabled.status, 0, enabled.stderr);
+  assert.deepEqual(JSON.parse(enabled.stdout), {
+    schema: 'throughline.runtime_error_config.v1',
+    collection: { enabled: true },
+  });
   for (const args of [
     ['runtime-errors', 'snapshot', '--json'],
     ['runtime-errors', 'diagnostics', '--json'],