@openturtle/cli 0.3.2 → 0.3.3

package/dist/commands/hook.js

@@ -1,162 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import path from 'node:path';
-import { compactJson } from '../core/json.js';
-import { findWorkspaceRoot } from '../core/paths.js';
-import { initProjectStore, recordCommit, recordHookRun, upsertEvent } from '../core/store.js';
-const EVENT_MAP = {
-    UserPromptSubmit: 'agent.user_prompt',
-    userPromptSubmit: 'agent.user_prompt',
-    user_prompt_submit: 'agent.user_prompt',
-    pre_tool_use: 'agent.pre_tool_use',
-    PreToolUse: 'agent.pre_tool_use',
-    preToolUse: 'agent.pre_tool_use',
-    post_tool_use: 'agent.post_tool_use',
-    PostToolUse: 'agent.post_tool_use',
-    postToolUse: 'agent.post_tool_use',
-    PostToolUseFailure: 'agent.post_tool_use_failure',
-    postToolUseFailure: 'agent.post_tool_use_failure',
-    Stop: 'agent.stop',
-    stop: 'agent.stop',
-    agentSpawn: 'agent.spawn',
-    AgentSpawn: 'agent.spawn',
-};
-export function ingestHookPayload(store, input) {
-    const type = EVENT_MAP[input.event] || EVENT_MAP[camelToPascal(input.event)] || 'agent.session_imported';
-    const sourceId = stringValue(input.payload.session_id ||
-        input.payload.sessionId ||
-        input.payload.conversation_id ||
-        input.payload.conversationId ||
-        input.payload.request_id ||
-        input.payload.requestId);
-    const sequence = stringValue(input.payload.sequence ||
-        input.payload.sequence_number ||
-        input.payload.event_id ||
-        input.payload.eventId ||
-        input.payload.tool_use_id ||
-        input.payload.toolUseId ||
-        input.payload.request_id ||
-        input.payload.requestId);
-    const workspacePath = stringValue(input.payload.cwd || input.payload.workspace_path || input.payload.workspacePath) || store.workspace;
-    const summary = summarizeHookPayload(type, input.payload);
-    const stableId = sourceId || hashText(compactJson(input.payload)).slice(0, 16);
-    const stableSequence = sequence || hashText(`${input.event}:${summary}:${compactJson(input.payload)}`).slice(0, 16);
-    const dedupeKey = `${input.target}:${type}:${stableId}:${stableSequence}`;
-    const result = upsertEvent(store, {
-        type,
-        source: input.target,
-        sourceId,
-        workspacePath,
-        summary,
-        rawJson: input.payload,
-        occurredAt: stringValue(input.payload.timestamp || input.payload.occurred_at) || new Date().toISOString(),
-        dedupeKey,
-    });
-    return { ok: true, inserted: result.inserted, dedupeKey };
-}
-export function ingestRawHook(options) {
-    const started = Date.now();
-    const workspace = options.workspace || findWorkspaceRoot();
-    const store = initProjectStore(workspace);
-    try {
-        const payload = options.stdin.trim() ? JSON.parse(options.stdin) : {};
-        const normalized = payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : { value: payload };
-        const result = ingestHookPayload(store, {
-            target: options.target,
-            event: options.event,
-            payload: normalized,
-        });
-        recordHookRun(store, {
-            target: options.target,
-            eventType: options.event,
-            exitCode: 0,
-            durationMs: Date.now() - started,
-            rawInputJson: options.stdin,
-        });
-        return result;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        recordHookRun(store, {
-            target: options.target,
-            eventType: options.event,
-            exitCode: 0,
-            durationMs: Date.now() - started,
-            rawInputJson: options.stdin,
-            error: message,
-        });
-        return { ok: false, error: message };
-    }
-}
-export function recordGitPostCommit(workspace = findWorkspaceRoot()) {
-    const store = initProjectStore(workspace);
-    const hash = git(workspace, ['rev-parse', 'HEAD']).trim();
-    const message = git(workspace, ['log', '-1', '--pretty=%B']).trim();
-    const author = git(workspace, ['log', '-1', '--pretty=%an <%ae>']).trim();
-    const diffStat = git(workspace, ['diff-tree', '--stat', '--no-commit-id', '--root', '-r', hash]).trim();
-    const changedFiles = git(workspace, ['diff-tree', '--no-commit-id', '--name-only', '--root', '-r', hash])
-        .split(/\r?\n/)
-        .map((item) => item.trim())
-        .filter(Boolean);
-    const occurredAt = git(workspace, ['log', '-1', '--pretty=%cI']).trim() || new Date().toISOString();
-    recordCommit(store, { hash, message, author, diffStat, changedFiles, occurredAt });
-    upsertEvent(store, {
-        type: 'git.post_commit',
-        source: 'git',
-        sourceId: hash,
-        workspacePath: workspace,
-        summary: message.split(/\r?\n/)[0] || hash,
-        rawJson: { hash, message, author, diffStat, changedFiles },
-        occurredAt,
-        dedupeKey: `git:git.post_commit:${hash}:${hash}`,
-    });
-}
-function summarizeHookPayload(type, payload) {
-    if (type === 'agent.user_prompt') {
-        return truncate(stringValue(payload.prompt || payload.message || payload.text || payload.input) || 'User prompt');
-    }
-    const toolName = stringValue(payload.tool_name || payload.toolName || payload.name || payload.tool);
-    if (toolName)
-        return `${eventLabel(type)} ${toolName}`;
-    return eventLabel(type);
-}
-function eventLabel(type) {
-    return type.replace(/^agent\./, '').replaceAll('_', ' ');
-}
-function stringValue(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function truncate(value, limit = 240) {
-    return value.length <= limit ? value : `${value.slice(0, limit - 1)}...`;
-}
-function camelToPascal(value) {
-    return value ? `${value[0]?.toUpperCase()}${value.slice(1)}` : value;
-}
-function hashText(value) {
-    let hash = 0x811c9dc5;
-    for (let index = 0; index < value.length; index += 1) {
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16);
-}
-function git(cwd, args) {
-    return execFileSync('git', args, {
-        cwd,
-        encoding: 'utf-8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-    });
-}
-export function hookCommandArgs(target, event) {
-    return ['hook', 'ingest', '--target', target, '--event', event, '--stdin-json'];
-}
-export function hookCommand(target, event) {
-    return ['ot', ...hookCommandArgs(target, event).map(shellQuote)].join(' ');
-}
-export function shellQuote(value) {
-    if (/^[A-Za-z0-9_./:=@-]+$/.test(value))
-        return value;
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-export function workspaceFromPayload(payload, fallback = process.cwd()) {
-    return stringValue(payload.cwd || payload.workspacePath || payload.workspace_path) || path.resolve(fallback);
-}

package/dist/installers/git.js

@@ -1,63 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { ensureDir, projectWorklogDir } from '../core/paths.js';
-const MARKER = 'OPENTURTLE-CLI';
-export function installGitHook(workspace) {
-    const gitHooksDir = path.join(workspace, '.git', 'hooks');
-    ensureDir(gitHooksDir);
-    ensureDir(path.join(projectWorklogDir(workspace), 'hooks'));
-    const hookPath = path.join(gitHooksDir, 'post-commit');
-    const originalPath = path.join(projectWorklogDir(workspace), 'hooks', 'git-post-commit.original');
-    if (fs.existsSync(hookPath)) {
-        const current = fs.readFileSync(hookPath, 'utf-8');
-        if (current.includes(MARKER))
-            return { installed: false, hookPath };
-        fs.renameSync(hookPath, originalPath);
-    }
-    const wrapper = `#!/bin/sh
-# >>> ${MARKER}:git-post-commit
-original_status=0
-if [ -x "${originalPath}" ]; then
-  "${originalPath}" "$@"
-  original_status="$?"
-fi
-
-if command -v ot >/dev/null 2>&1; then
-  (cd "${workspace}" && ot hook git-post-commit >/dev/null 2>&1) || true
-fi
-
-exit "$original_status"
-# <<< ${MARKER}:git-post-commit
-`;
-    fs.writeFileSync(hookPath, wrapper, 'utf-8');
-    fs.chmodSync(hookPath, 0o755);
-    return { installed: true, hookPath };
-}
-export function uninstallGitHook(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 });
-    removeEmptyDir(path.dirname(originalPath));
-}
-function removeEmptyDir(dirPath) {
-    try {
-        if (fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0) {
-            fs.rmdirSync(dirPath);
-        }
-    }
-    catch {
-        // Uninstall should never fail because cleanup of an auxiliary directory failed.
-    }
-}

package/dist/mcp/server.js

@@ -1,185 +0,0 @@
-import readline from 'node:readline';
-import { createResourceCommands, draftDailyReport } from '../commands/resources.js';
-import { initProjectStore, listEvents, upsertEvent } from '../core/store.js';
-const TOOLS = [
-    tool('list_my_todos', 'List my OpenTurtle todos', {
-        type: 'object',
-        properties: {
-            project_id: { type: 'string' },
-            status: { type: 'string' },
-            mine: { type: 'boolean' },
-        },
-    }),
-    tool('list_goals', 'List OpenTurtle goals', {
-        type: 'object',
-        properties: {
-            project_id: { type: 'string' },
-            status: { type: 'string' },
-            mine: { type: 'boolean' },
-        },
-    }),
-    tool('list_workspace_knowledge', 'List reusable workspace knowledge objects', {
-        type: 'object',
-        properties: { project_id: { type: 'string' }, q: { type: 'string' } },
-    }),
-    tool('search_workspace_knowledge', 'Search reusable workspace knowledge objects', {
-        type: 'object',
-        properties: { keyword: { type: 'string' } },
-        required: ['keyword'],
-    }),
-    tool('list_knowledge_source_files', 'List source files behind workspace knowledge', {
-        type: 'object',
-        properties: { path: { type: 'string' }, q: { type: 'string' } },
-    }),
-    tool('read_knowledge_source_file', 'Read a source file behind workspace knowledge', {
-        type: 'object',
-        properties: { path: { type: 'string' } },
-        required: ['path'],
-    }),
-    tool('record_worklog', 'Record a work log entry', {
-        type: 'object',
-        properties: {
-            summary: { type: 'string' },
-            type: { type: 'string' },
-        },
-        required: ['summary'],
-    }),
-    tool('list_worklogs', 'List work logs', {
-        type: 'object',
-        properties: { today: { type: 'boolean' }, window: { type: 'string' } },
-    }),
-    tool('draft_daily_report', "Draft today's local daily report", {
-        type: 'object',
-        properties: { output: { type: 'string' } },
-    }),
-    tool('update_todo_progress', 'Update todo progress description with current progress, blockers, next step, and evidence such as logs, tests, screenshots, PRs, commits, or worklog references.', {
-        type: 'object',
-        properties: {
-            todo_id: { type: 'string' },
-            message: { type: 'string' },
-        },
-        required: ['todo_id', 'message'],
-    }),
-    tool('update_todo_status', 'Update todo status', {
-        type: 'object',
-        properties: {
-            todo_id: { type: 'string' },
-            status: { type: 'string' },
-        },
-        required: ['todo_id', 'status'],
-    }),
-];
-export async function handleMcpRequest(msg) {
-    const { id, method, params } = msg;
-    switch (method) {
-        case 'initialize':
-            return result(id, {
-                protocolVersion: '2024-11-05',
-                capabilities: { tools: {} },
-                serverInfo: { name: 'ot-cli', version: '0.2.0' },
-            });
-        case 'notifications/initialized':
-            return { jsonrpc: '2.0' };
-        case 'tools/list':
-            return result(id, { tools: TOOLS });
-        case 'tools/call': {
-            const name = String(params?.name || '');
-            const args = (params?.arguments || {});
-            try {
-                const output = await handleTool(name, args);
-                return result(id, { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] });
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return result(id, { content: [{ type: 'text', text: `Error: ${message}` }], isError: true });
-            }
-        }
-        case 'ping':
-            return result(id, {});
-        default:
-            return error(id, -32601, `Method not found: ${method}`);
-    }
-}
-export async function serveMcp() {
-    const rl = readline.createInterface({ input: process.stdin });
-    for await (const line of rl) {
-        if (!line.trim())
-            continue;
-        try {
-            const response = await handleMcpRequest(JSON.parse(line));
-            if (response.id !== undefined || response.result || response.error) {
-                process.stdout.write(`${JSON.stringify(response)}\n`);
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`[ot-cli-mcp] parse error: ${message}\n`);
-        }
-    }
-}
-async function handleTool(name, args) {
-    const commands = createResourceCommands();
-    try {
-        if (name === 'list_my_todos')
-            return await commands.listTodos({ ...args, mine: args.mine ?? true });
-        if (name === 'list_goals')
-            return await commands.listGoals(args);
-        if (name === 'list_workspace_knowledge')
-            return await commands.listKnowledge(args);
-        if (name === 'search_workspace_knowledge')
-            return await commands.searchKnowledge(String(args.keyword || ''));
-        if (name === 'list_knowledge_source_files')
-            return await commands.listKnowledgeSources(args);
-        if (name === 'read_knowledge_source_file')
-            return await commands.readKnowledgeSource(String(args.path || ''));
-        if (name === 'record_worklog')
-            return await commands.recordWorklog(String(args.summary || ''), String(args.type || 'note'));
-        if (name === 'list_worklogs')
-            return await commands.listWorklogs(args);
-        if (name === 'update_todo_progress') {
-            return await commands.updateTodoProgress(String(args.todo_id || ''), String(args.message || ''));
-        }
-        if (name === 'update_todo_status') {
-            return await commands.updateTodoStatus(String(args.todo_id || ''), String(args.status || ''));
-        }
-    }
-    catch (err) {
-        return localFallback(name, args, err);
-    }
-    if (name === 'draft_daily_report') {
-        return { source: 'local_cache', path: draftDailyReport(process.cwd(), { output: stringArg(args.output) }) };
-    }
-    throw new Error(`Unknown tool: ${name}`);
-}
-function localFallback(name, args, err) {
-    if (name === 'record_worklog') {
-        const store = initProjectStore(process.cwd());
-        upsertEvent(store, {
-            type: 'agent.session_imported',
-            source: 'codex',
-            workspacePath: process.cwd(),
-            summary: String(args.summary || ''),
-            rawJson: { tool: name, args },
-            dedupeKey: `local:record_worklog:${Date.now()}:${Math.random().toString(16).slice(2)}`,
-        });
-        return { source: 'local_cache', ok: true };
-    }
-    const store = initProjectStore(process.cwd());
-    return {
-        source: 'local_cache',
-        warning: err instanceof Error ? err.message : String(err),
-        events: listEvents(store, 50),
-    };
-}
-function tool(name, description, inputSchema) {
-    return { name, description, inputSchema };
-}
-function result(id, value) {
-    return { jsonrpc: '2.0', id: id ?? 0, result: value };
-}
-function error(id, code, message) {
-    return { jsonrpc: '2.0', id: id ?? 0, error: { code, message } };
-}
-function stringArg(value) {
-    return typeof value === 'string' && value ? value : undefined;
-}

package/dist/watchers/importers.js

@@ -1,69 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { initProjectStore, upsertEvent } from '../core/store.js';
-export function candidateHistoryPaths(target, homeDir = os.homedir()) {
-    if (target === 'qoder') {
-        return [
-            path.join(homeDir, '.qoder', 'logs', 'runs'),
-            path.join(homeDir, '.qoder', 'projects'),
-            path.join(homeDir, '.qoderwork', 'projects'),
-        ];
-    }
-    if (target === 'kiro') {
-        return [path.join(homeDir, '.kiro', 'sessions', 'cli')];
-    }
-    if (target === 'codex')
-        return [path.join(homeDir, '.codex', 'sessions')];
-    if (target === 'claude')
-        return [path.join(homeDir, '.claude', 'projects')];
-    return [];
-}
-export function importHistory(target, workspace = process.cwd()) {
-    const store = initProjectStore(workspace);
-    const paths = candidateHistoryPaths(target);
-    let imported = 0;
-    for (const filePath of paths.flatMap((item) => walkFiles(item))) {
-        const stat = safeStat(filePath);
-        if (!stat || stat.size <= 0)
-            continue;
-        const dedupeKey = `${target}:agent.session_imported:${filePath}:${stat.mtimeMs}`;
-        const result = upsertEvent(store, {
-            type: 'agent.session_imported',
-            source: target,
-            workspacePath: workspace,
-            summary: `Imported ${path.basename(filePath)}`,
-            rawJson: { filePath, size: stat.size, mtimeMs: stat.mtimeMs },
-            occurredAt: new Date(stat.mtimeMs).toISOString(),
-            dedupeKey,
-        });
-        if (result.inserted)
-            imported += 1;
-    }
-    return { imported, paths };
-}
-function walkFiles(root) {
-    let entries;
-    try {
-        entries = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return entries.flatMap((entry) => {
-        const entryPath = path.join(root, entry.name);
-        if (entry.isDirectory())
-            return walkFiles(entryPath);
-        if (entry.isFile() && /\.(jsonl|json|log)$/i.test(entry.name))
-            return [entryPath];
-        return [];
-    });
-}
-function safeStat(filePath) {
-    try {
-        return fs.statSync(filePath);
-    }
-    catch {
-        return null;
-    }
-}