@openturtle/cli 0.3.2 → 0.3.4

package/dist/installers/agents.js

@@ -1,158 +1,117 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { hookCommand } from '../commands/hook.js';
-import { readJsonFile, writeJsonFile } from '../core/json.js';
-import { appendCodexHookBlocks, claudeMcpPath, claudeSettingsPath, codexConfigPath, cursorMcpPath, kiroMcpPath, mergeCodexMcpServer, mergeJsonMcpServer, qoderMcpPath, removeCodexManagedConfig, removeJsonMcpServer, } from '../core/mcp-config.js';
+import { fileURLToPath } from 'node:url';
+import { readJsonFile } from '../core/json.js';
+import { claudeLegacyServerPath, claudeSettingsPath, codexConfigPath, cursorLegacyServerPath, kiroLegacyServerPath, qoderLegacyServerPath, removeLegacyCodexConfig, removeLegacyJsonServer, } from '../core/legacy-agent-cleanup.js';
 import { ensureFileDir } from '../core/paths.js';
 import { removeCursorHookEntries, removeDirIfExists, removeFileIfExists, removeManagedHookEntries, writeJsonOrRemoveEmpty, } from './uninstall.js';
 export function installClaude(options) {
-    mergeJsonMcpServer(claudeMcpPath(options.scope, options.workspace, options.homeDir));
-    writeSkill(path.join(rootForScope(options, '.claude'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Claude');
-    if (options.withAgentHooks) {
-        mergeJsonMcpServerInSettings(claudeSettingsPath(options.scope, options.workspace, options.homeDir));
-        const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
-        const settings = readJsonFile(settingsPath, {});
-        const hooks = settings.hooks || {};
-        settings.hooks = {
-            ...hooks,
-            UserPromptSubmit: mergeManagedHookArray(hooks.UserPromptSubmit, managedHook('claude', 'UserPromptSubmit')),
-            PreToolUse: mergeManagedHookArray(hooks.PreToolUse, managedHook('claude', 'PreToolUse', '*')),
-            PostToolUse: mergeManagedHookArray(hooks.PostToolUse, managedHook('claude', 'PostToolUse', '*')),
-            Stop: mergeManagedHookArray(hooks.Stop, managedHook('claude', 'Stop')),
-        };
-        writeJsonFile(settingsPath, settings);
-    }
+    cleanupClaudeLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.claude'), 'skills', 'openturtle-cli', 'SKILL.md'));
 }
 export function installCodex(options) {
-    const configPath = codexConfigPath(options.scope, options.workspace, options.homeDir);
-    mergeCodexMcpServer(configPath);
-    writeSkill(path.join(rootForScope(options, '.codex'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Codex');
-    appendAgentsSnippet(options.workspace);
-    if (options.withAgentHooks) {
-        appendCodexHookBlocks(configPath, [
-            codexHookBlock('PreToolUse', 'codex', 'PreToolUse'),
-            codexHookBlock('PostToolUse', 'codex', 'PostToolUse'),
-            codexHookBlock('Stop', 'codex', 'Stop'),
-        ].join('\n\n'));
-    }
+    cleanupCodexLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.codex'), 'skills', 'openturtle-cli', 'SKILL.md'));
+    if (options.scope === 'project')
+        appendAgentsSnippet(options.workspace);
 }
 export function installCursor(options) {
-    mergeJsonMcpServer(cursorMcpPath(options.workspace));
+    cleanupCursorLegacy(options);
     writeTextFile(path.join(options.workspace, '.cursor', 'rules', 'openturtle-cli.mdc'), [
         '---',
-        'description: Use OpenTurtle CLI MCP tools for goals, todos, reusable knowledge, source files, worklogs, and report drafts.',
+        'description: Use the OpenTurtle CLI directly for projects, goals, todos, knowledge, meetings, and worklogs.',
         'alwaysApply: true',
         '---',
         '',
-        'Prefer the `ot-cli` MCP server when reading or updating OpenTurtle goals, todos, worklogs, reports, or reusable workspace knowledge.',
-        'Use knowledge source-file tools only when you need the original files behind a knowledge object.',
-        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
+        'Run OpenTurtle operations with the direct `ot ... --json` CLI. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Start with `command -v ot` and `ot --json doctor`; if authentication is missing, ask the user to run `ot auth login --web`.',
+        'Before a write, run the same command with `--dry-run` and inspect the request path and body.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
     ].join('\n'));
-    if (options.withAgentHooks) {
-        const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
-        const hooks = readJsonFile(hooksPath, {});
-        hooks.preToolUse = mergeManagedHookArray(hooks.preToolUse, cursorHook('cursor', 'pre_tool_use'));
-        hooks.postToolUse = mergeManagedHookArray(hooks.postToolUse, cursorHook('cursor', 'post_tool_use'));
-        writeJsonFile(hooksPath, hooks);
-    }
 }
 export function installQoder(options) {
-    mergeJsonMcpServer(qoderMcpPath(options.scope, options.workspace, options.homeDir));
-    writeSkill(path.join(rootForScope(options, '.qoder'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Qoder');
-    if (options.withAgentHooks) {
-        const settingsPath = options.scope === 'user'
-            ? path.join(options.homeDir || os.homedir(), '.qoder', 'settings.json')
-            : path.join(options.workspace, '.qoder', 'settings.local.json');
-        const settings = readJsonFile(settingsPath, {});
-        const hooks = settings.hooks || {};
-        settings.hooks = {
-            ...hooks,
-            UserPromptSubmit: mergeManagedHookArray(hooks.UserPromptSubmit, managedHook('qoder', 'UserPromptSubmit')),
-            PreToolUse: mergeManagedHookArray(hooks.PreToolUse, managedHook('qoder', 'PreToolUse', '*')),
-            PostToolUse: mergeManagedHookArray(hooks.PostToolUse, managedHook('qoder', 'PostToolUse', '*')),
-            PostToolUseFailure: mergeManagedHookArray(hooks.PostToolUseFailure, managedHook('qoder', 'PostToolUseFailure', '*')),
-            Stop: mergeManagedHookArray(hooks.Stop, managedHook('qoder', 'Stop')),
-        };
-        writeJsonFile(settingsPath, settings);
-    }
+    cleanupQoderLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.qoder'), 'skills', 'openturtle-cli', 'SKILL.md'));
 }
 export function installKiro(options) {
-    mergeJsonMcpServer(kiroMcpPath(options.scope, options.workspace, options.homeDir));
+    cleanupKiroLegacy(options);
     writeTextFile(path.join(rootForScope(options, '.kiro'), 'steering', 'openturtle-cli.md'), [
         '# OpenTurtle CLI',
         '',
-        'Use the `ot-cli` MCP server for OpenTurtle goals, todos, reusable knowledge, source files, worklogs, and daily report drafts.',
-        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
-        'Hooks installed by OpenTurtle are audit-only and must not block the user workflow.',
+        'Run OpenTurtle operations with the direct `ot ... --json` CLI. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Start with `command -v ot` and `ot --json doctor`; if authentication is missing, ask the user to run `ot auth login --web`.',
+        'Before a write, run the same command with `--dry-run` and inspect the request path and body.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
     ].join('\n'));
-    if (options.withAgentHooks) {
-        const agentPath = path.join(rootForScope(options, '.kiro'), 'agents', 'openturtle-cli.json');
-        const agent = readJsonFile(agentPath, {});
-        const hooks = agent.hooks || {};
-        agent.name = 'openturtle-cli';
-        agent.description = 'OpenTurtle local audit and MCP integration';
-        agent.hooks = {
-            ...hooks,
-            agentSpawn: managedKiroHookList('agentSpawn'),
-            userPromptSubmit: managedKiroHookList('userPromptSubmit'),
-            preToolUse: managedKiroHookList('preToolUse', '*'),
-            postToolUse: managedKiroHookList('postToolUse', '*'),
-            stop: managedKiroHookList('stop'),
-        };
-        writeJsonFile(agentPath, agent);
-        writeKiroIdeHook(path.join(rootForScope(options, '.kiro'), 'hooks', 'openturtle-cli-audit.kiro.hook'));
-    }
 }
 export function uninstallClaude(options) {
+    cleanupClaudeLegacy(options);
     const root = rootForScope(options, '.claude');
-    removeJsonMcpServer(claudeMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', root);
-    const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
-    if (fs.existsSync(settingsPath)) {
-        const settings = readJsonFile(settingsPath, {});
-        if (settings.mcpServers && typeof settings.mcpServers === 'object') {
-            delete settings.mcpServers['ot-cli'];
-        }
-        writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
-    }
     removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
 }
 export function uninstallCodex(options) {
+    cleanupCodexLegacy(options);
     const root = rootForScope(options, '.codex');
-    removeCodexManagedConfig(codexConfigPath(options.scope, options.workspace, options.homeDir), root);
     removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
-    removeAgentsSnippet(options.workspace);
+    if (options.scope === 'project')
+        removeAgentsSnippet(options.workspace);
 }
 export function uninstallCursor(options) {
-    removeJsonMcpServer(cursorMcpPath(options.workspace), 'ot-cli', options.workspace);
+    cleanupCursorLegacy(options);
     const root = path.join(options.workspace, '.cursor');
     removeFileIfExists(path.join(root, 'rules', 'openturtle-cli.mdc'), root);
-    const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
-    if (fs.existsSync(hooksPath)) {
-        const hooks = readJsonFile(hooksPath, {});
-        writeJsonOrRemoveEmpty(hooksPath, removeCursorHookEntries(hooks), path.dirname(hooksPath));
-    }
 }
 export function uninstallQoder(options) {
+    cleanupQoderLegacy(options);
     const root = rootForScope(options, '.qoder');
-    removeJsonMcpServer(qoderMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', options.scope === 'user'
-        ? path.dirname(qoderMcpPath(options.scope, options.workspace, options.homeDir))
-        : options.workspace);
     removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
+}
+export function uninstallKiro(options) {
+    cleanupKiroLegacy(options);
+    const root = rootForScope(options, '.kiro');
+    removeFileIfExists(path.join(root, 'steering', 'openturtle-cli.md'), root);
+}
+function cleanupClaudeLegacy(options) {
+    const root = rootForScope(options, '.claude');
+    removeLegacyJsonServer(claudeLegacyServerPath(options.scope, options.workspace, options.homeDir), root);
+    const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
+    if (!fs.existsSync(settingsPath))
+        return;
+    const settings = readJsonFile(settingsPath, {});
+    if (settings.mcpServers && typeof settings.mcpServers === 'object')
+        delete settings.mcpServers['ot-cli'];
+    writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
+}
+function cleanupCodexLegacy(options) {
+    const root = rootForScope(options, '.codex');
+    removeLegacyCodexConfig(codexConfigPath(options.scope, options.workspace, options.homeDir), root);
+}
+function cleanupCursorLegacy(options) {
+    removeLegacyJsonServer(cursorLegacyServerPath(options.workspace), options.workspace);
+    const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
+    if (!fs.existsSync(hooksPath))
+        return;
+    const hooks = readJsonFile(hooksPath, {});
+    writeJsonOrRemoveEmpty(hooksPath, removeCursorHookEntries(hooks), path.dirname(hooksPath));
+}
+function cleanupQoderLegacy(options) {
+    const root = rootForScope(options, '.qoder');
+    const mcpPath = qoderLegacyServerPath(options.scope, options.workspace, options.homeDir);
+    removeLegacyJsonServer(mcpPath, options.scope === 'user' ? path.dirname(mcpPath) : options.workspace);
     const settingsPath = options.scope === 'user'
         ? path.join(options.homeDir || os.homedir(), '.qoder', 'settings.json')
         : path.join(options.workspace, '.qoder', 'settings.local.json');
-    if (fs.existsSync(settingsPath)) {
-        const settings = readJsonFile(settingsPath, {});
-        writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
-    }
+    if (!fs.existsSync(settingsPath))
+        return;
+    const settings = readJsonFile(settingsPath, {});
+    writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
 }
-export function uninstallKiro(options) {
+function cleanupKiroLegacy(options) {
     const root = rootForScope(options, '.kiro');
-    removeJsonMcpServer(kiroMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', root);
-    removeFileIfExists(path.join(root, 'steering', 'openturtle-cli.md'), root);
+    removeLegacyJsonServer(kiroLegacyServerPath(options.scope, options.workspace, options.homeDir), root);
     removeFileIfExists(path.join(root, 'agents', 'openturtle-cli.json'), root);
     removeFileIfExists(path.join(root, 'hooks', 'openturtle-cli-audit.kiro.hook'), root);
 }
@@ -161,108 +120,26 @@ function rootForScope(options, dirName) {
         ? path.join(options.homeDir || os.homedir(), dirName)
         : path.join(options.workspace, dirName);
 }
-function mergeJsonMcpServerInSettings(settingsPath) {
-    const settings = readJsonFile(settingsPath, {});
-    const servers = settings.mcpServers && typeof settings.mcpServers === 'object'
-        ? settings.mcpServers
-        : {};
-    servers['ot-cli'] = { command: 'ot', args: ['mcp', 'serve'], enabled: true };
-    writeJsonFile(settingsPath, { ...settings, mcpServers: servers });
+function writeSkill(filePath) {
+    writeTextFile(filePath, skillContent());
 }
-function managedHook(target, event, matcher) {
-    return withoutUndefined({
-        id: 'OPENTURTLE-CLI',
-        name: 'OPENTURTLE-CLI audit',
-        matcher,
-        command: hookCommand(target, event),
-        timeout_ms: 2000,
-        continue_on_error: true,
-    });
-}
-function managedKiroHookList(event, matcher) {
-    return [
-        withoutUndefined({
-            id: 'OPENTURTLE-CLI',
-            name: 'OPENTURTLE-CLI audit',
-            matcher,
-            command: hookCommand('kiro', event),
-            timeout_ms: 2000,
-            cache_ttl_seconds: 0,
-            continue_on_error: true,
-        }),
-    ];
-}
-function cursorHook(target, event) {
-    return {
-        id: 'OPENTURTLE-CLI',
-        command: hookCommand(target, event),
-        timeout_ms: 2000,
-        continue_on_error: true,
-    };
-}
-function mergeManagedHookArray(existing, entry) {
-    const values = Array.isArray(existing) ? existing.filter((item) => item?.id !== 'OPENTURTLE-CLI') : [];
-    return [...values, entry];
-}
-function codexHookBlock(hook, target, event) {
-    return [
-        `[[hooks.${hook}]]`,
-        `command = "ot"`,
-        `args = ["hook", "ingest", "--target", "${target}", "--event", "${event}", "--stdin-json"]`,
-        `timeout_ms = 2000`,
-    ].join('\n');
-}
-function writeSkill(filePath, agentName) {
-    writeTextFile(filePath, [
-        '---',
-        'name: openturtle-cli',
-        'description: Use OpenTurtle projects, team roster, project context, knowledge, meetings, goals, todos, and worklogs from an agent or terminal without requiring the Desktop client.',
-        '---',
-        '',
-        '# OpenTurtle CLI',
-        '',
-        `Use the \`ot-cli\` MCP server in ${agentName} when its tool covers the task. Use the direct \`ot\` command for projects, roster, project context, meetings, or any newer operation that is not exposed by MCP.`,
-        'If authentication is missing, ask the user to run `ot auth login --web`; never request or expose their browser token.',
-        'Run `ot --json doctor` before a remote workflow when authentication or server reachability is uncertain.',
-        'Read commands emit JSON. Before a write, run the same command with `--dry-run` and inspect `request.path` and `request.body`.',
-        'Treat knowledge as reusable memory objects. Treat source files as original materials referenced by knowledge, not as a second knowledge system.',
-        '',
-        '## Meeting workflow',
-        '',
-        '1. Resolve the project with `ot projects resolve`, then inspect `ot roster list` and `ot context get`.',
-        '2. Upload audio with `ot meetings upload` or inspect an existing meeting with `ot meetings show`, `transcript`, and `minutes`.',
-        '3. Publish complete minutes with `ot meetings publish <meeting-id>`. Meeting minutes belong in Knowledge, not WorkLog.',
-        '4. Review drafts using `ot meetings updates list <meeting-id>` and edit them when needed.',
-        '5. Confirm only reviewed updates with `ot meetings updates confirm ... --knowledge <knowledge-id>`. Never confirm without the saved meeting knowledge id.',
-        '6. Use the materialized Todo or WorkLog ids returned by confirmation as the project update evidence.',
-        '',
-        '## Todo quality',
-        '',
-        'When creating or proposing OpenTurtle todos through any available OpenTurtle MCP tool, include source context, scope/environment, concrete action steps, measurable acceptance criteria, and required evidence.',
-        'Source context means the goal, meeting, plan artifact, commit, PR, file, worklog, or user request that caused the todo.',
-        'If the source context, environment, owner, due date, measurable acceptance criteria, or evidence is unclear, ask the user first. Use AskUserQuestion when the host supports it; otherwise ask one concise question before creating the todo.',
-        'Avoid vague acceptance such as "no obvious delay", "works normally", or "verify it". Prefer concrete thresholds, environments, and evidence.',
-        'Use `--body-file <json>` or `--body-file -` for structured writes so shell quoting does not corrupt payloads.',
-        'Do not write to `.openturtle/`; CLI state lives in `.openturtle-cli/` and `~/.openturtle/cli/`.',
-        '',
-    ].join('\n'));
+export function skillContent() {
+    return fs.readFileSync(fileURLToPath(new URL('../../skill/openturtle-cli/SKILL.md', import.meta.url)), 'utf8');
 }
 function appendAgentsSnippet(workspace) {
     const filePath = path.join(workspace, 'AGENTS.md');
     const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
-    const marker = '<!-- OPENTURTLE-CLI -->';
-    if (existing.includes(marker))
-        return;
+    const withoutOld = existing.replace(/<!-- OPENTURTLE-CLI -->[\s\S]*?<!-- \/OPENTURTLE-CLI -->\n?/m, '').trimEnd();
     const snippet = [
-        marker,
+        '<!-- OPENTURTLE-CLI -->',
         '',
-        'When OpenTurtle goals, todos, reusable knowledge, source files, worklogs, or report drafts are needed, prefer the `ot-cli` MCP server.',
-        'Knowledge means reusable memory objects; source files are original materials behind knowledge.',
-        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
+        'Use the direct `ot ... --json` CLI for OpenTurtle projects, goals, todos, knowledge, meetings, and worklogs. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Run `ot --json doctor` when authentication or server reachability is uncertain, and use `--dry-run` before writes.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
         '<!-- /OPENTURTLE-CLI -->',
     ].join('\n');
-    writeTextFile(filePath, `${existing.trimEnd()}${existing.trim() ? '\n\n' : ''}${snippet}\n`);
+    writeTextFile(filePath, `${withoutOld}${withoutOld ? '\n\n' : ''}${snippet}\n`);
 }
 function removeAgentsSnippet(workspace) {
     const filePath = path.join(workspace, 'AGENTS.md');
@@ -270,32 +147,12 @@ function removeAgentsSnippet(workspace) {
         return;
     const content = fs.readFileSync(filePath, 'utf-8');
     const cleaned = content.replace(/<!-- OPENTURTLE-CLI -->[\s\S]*?<!-- \/OPENTURTLE-CLI -->\n?/m, '').trimEnd();
-    if (cleaned) {
+    if (cleaned)
         fs.writeFileSync(filePath, `${cleaned}\n`, 'utf-8');
-    }
-    else {
+    else
         fs.rmSync(filePath, { force: true });
-    }
-}
-function writeKiroIdeHook(filePath) {
-    writeTextFile(filePath, [
-        '{',
-        '  "name": "OpenTurtle CLI audit",',
-        '  "description": "Record Kiro hook events into .openturtle-cli/state.db",',
-        '  "event": "postToolUse",',
-        '  "action": {',
-        '    "type": "command",',
-        `    "command": "${hookCommand('kiro', 'postToolUse').replaceAll('"', '\\"')}",`,
-        '    "timeout_ms": 2000',
-        '  }',
-        '}',
-        '',
-    ].join('\n'));
 }
 function writeTextFile(filePath, content) {
     ensureFileDir(filePath);
     fs.writeFileSync(filePath, content, 'utf-8');
 }
-function withoutUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
-}

package/dist/installers/legacy-git-cleanup.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectWorklogDir } from '../core/paths.js';
+const MARKER = 'OPENTURTLE-CLI';
+export function uninstallLegacyGitHook(workspace) {
+    const hookPath = path.join(workspace, '.git', 'hooks', 'post-commit');
+    const originalPath = path.join(projectWorklogDir(workspace), 'hooks', 'git-post-commit.original');
+    if (!fs.existsSync(hookPath))
+        return;
+    const current = fs.readFileSync(hookPath, 'utf-8');
+    if (!current.includes(MARKER))
+        return;
+    if (fs.existsSync(originalPath)) {
+        fs.copyFileSync(originalPath, hookPath);
+        fs.chmodSync(hookPath, 0o755);
+    }
+    else {
+        fs.unlinkSync(hookPath);
+    }
+    fs.rmSync(originalPath, { force: true });
+    try {
+        if (fs.existsSync(path.dirname(originalPath)) && fs.readdirSync(path.dirname(originalPath)).length === 0) {
+            fs.rmdirSync(path.dirname(originalPath));
+        }
+    }
+    catch {
+        // Legacy cleanup should not fail because an auxiliary directory is not empty.
+    }
+}