@openturtle/cli 0.3.0

package/dist/commands/collaboration.js

@@ -0,0 +1,315 @@
+import { ApiClient, listQuery } from '../core/api-client.js';
+import { collectOption, parseKeyValueOptions, readJsonBody } from '../core/input.js';
+export function createCollaborationCommands(client = new ApiClient()) {
+    const mutate = async (method, path, body, dryRun = false) => {
+        if (dryRun)
+            return dryRunRequest(method, path, body);
+        return client.request(method, path, body);
+    };
+    return {
+        listProjects: (options) => client.get('/api/projects', listQuery(options)),
+        showProject: async (projectId, includeMembers = false) => {
+            const project = await client.get(`/api/projects/${encodeURIComponent(projectId)}`);
+            if (!includeMembers)
+                return project;
+            const members = await client.get(`/api/projects/${encodeURIComponent(projectId)}/members`);
+            return { project, members };
+        },
+        async resolveProject(query) {
+            const response = await client.get('/api/projects', {
+                keyword: query,
+                activated_only: false,
+                page_size: 100,
+            });
+            const items = Array.isArray(response) ? response : response.items || [];
+            const exact = items.find((item) => item.id === query || String(item.name || '').toLowerCase() === query.toLowerCase());
+            return {
+                resolved: Boolean(exact),
+                project: exact || null,
+                candidates: exact ? [] : items,
+            };
+        },
+        async listRoster(teamId) {
+            const team = teamId ? { id: teamId } : await client.get('/api/teams/me');
+            const resolvedTeamId = String(team.id || teamId || '');
+            if (!resolvedTeamId)
+                throw new Error('Current team response did not include an id');
+            const [members, profile, rosterProfile] = await Promise.all([
+                client.get(`/api/teams/${encodeURIComponent(resolvedTeamId)}/members`, { page_size: 100 }),
+                client.get('/api/me/profile').catch(() => null),
+                client.get('/api/me/roster-profile').catch(() => null),
+            ]);
+            return { team, profile, roster_profile: rosterProfile, members };
+        },
+        resolveContext: (body) => client.post('/api/project-context/resolve', body),
+        getContextItem: (sourceType, sourceId, options) => client.get(`/api/project-context/items/${encodeURIComponent(sourceType)}/${encodeURIComponent(sourceId)}`, listQuery(options)),
+        relations: (knowledgeId) => client.get(`/api/memory/objects/${encodeURIComponent(knowledgeId)}/relations`),
+        saveKnowledge: (knowledgeId, body, dryRun = false) => mutate(knowledgeId ? 'PATCH' : 'POST', knowledgeId ? `/api/memory/objects/${encodeURIComponent(knowledgeId)}` : '/api/memory/objects', body, dryRun),
+        attachKnowledge: async (knowledgeId, files, dryRun = false) => {
+            const path = `/api/memory/objects/${encodeURIComponent(knowledgeId)}/attachments`;
+            if (dryRun)
+                return dryRunRequest('POST', path, { files });
+            return client.upload('POST', path, files.map((filePath) => ({ field: 'files', filePath })));
+        },
+        readKnowledgeAttachment: (knowledgeId, attachmentId, truncate) => client.get(`/api/memory/objects/${encodeURIComponent(knowledgeId)}/attachments/${encodeURIComponent(attachmentId)}/content`, { truncate }),
+        downloadKnowledgeAttachment: (knowledgeId, attachmentId, output, force = false, dryRun = false) => {
+            const path = `/api/memory/objects/${encodeURIComponent(knowledgeId)}/attachments/${encodeURIComponent(attachmentId)}/download`;
+            if (dryRun)
+                return Promise.resolve(dryRunDownload(path, output, force));
+            return client.download(path, output, force);
+        },
+        listMeetings: (options) => client.get('/api/meeting', listQuery(options)),
+        showMeeting: (meetingId) => client.get(`/api/meeting/${encodeURIComponent(meetingId)}/detail`),
+        meetingPart: (meetingId, part) => client.get(`/api/meeting/${encodeURIComponent(meetingId)}/${part}`),
+        createMeeting: (body, dryRun = false) => mutate('POST', '/api/meeting', body, dryRun),
+        uploadMeeting: async (filePath, options, dryRun = false) => {
+            const fields = listQuery({ project_id: options.project, goal_id: options.goal, title: options.title });
+            if (dryRun)
+                return dryRunRequest('POST', '/api/meeting/upload', { file: filePath, ...fields });
+            return client.upload('POST', '/api/meeting/upload', [{ field: 'file', filePath }], fields);
+        },
+        retryMeeting: (meetingId, dryRun = false) => mutate('POST', `/api/meeting/${encodeURIComponent(meetingId)}/processing/retry`, undefined, dryRun),
+        publishMeetingKnowledge: (meetingId, dryRun = false) => mutate('POST', `/api/meeting/${encodeURIComponent(meetingId)}/knowledge/publish`, undefined, dryRun),
+        downloadMeetingRecording: (meetingId, output, force = false, dryRun = false) => {
+            const path = `/api/meeting/${encodeURIComponent(meetingId)}/recording/download`;
+            if (dryRun)
+                return Promise.resolve(dryRunDownload(path, output, force));
+            return client.download(path, output, force);
+        },
+        listProjectUpdates: (meetingId) => client.get(`/api/meeting/${encodeURIComponent(meetingId)}/project-updates`),
+        editProjectUpdate: (meetingId, updateId, body, dryRun = false) => mutate('PATCH', `/api/meeting/${encodeURIComponent(meetingId)}/project-updates/${encodeURIComponent(updateId)}`, body, dryRun),
+        confirmProjectUpdates: (meetingId, updateIds, projectId, knowledgeId, dryRun = false) => mutate('POST', `/api/meeting/${encodeURIComponent(meetingId)}/project-updates/confirm`, { project_id: projectId, knowledge_id: knowledgeId, update_ids: updateIds }, dryRun),
+        ignoreProjectUpdate: (meetingId, updateId, dryRun = false) => mutate('POST', `/api/meeting/${encodeURIComponent(meetingId)}/project-updates/${encodeURIComponent(updateId)}/ignore`, undefined, dryRun),
+        createGoal: (body, dryRun = false) => mutate('POST', '/api/goals', body, dryRun),
+        updateGoal: (goalId, body, dryRun = false) => mutate('PATCH', `/api/goals/${encodeURIComponent(goalId)}`, body, dryRun),
+        submitGoalReview: (goalId, body, dryRun = false) => mutate('POST', `/api/goals/${encodeURIComponent(goalId)}/submit-review`, body, dryRun),
+        reviewGoal: (goalId, body, dryRun = false) => mutate('POST', `/api/goals/${encodeURIComponent(goalId)}/review`, body, dryRun),
+        createTodo: (body, dryRun = false) => mutate('POST', '/api/todos', body, dryRun),
+        updateTodo: (todoId, body, dryRun = false) => mutate('PATCH', `/api/todos/${encodeURIComponent(todoId)}`, body, dryRun),
+        submitTodoReview: (todoId, body, dryRun = false) => mutate('POST', `/api/todos/${encodeURIComponent(todoId)}/submit-review`, body, dryRun),
+        reviewTodo: (todoId, body, dryRun = false) => mutate('POST', `/api/todos/${encodeURIComponent(todoId)}/review`, body, dryRun),
+        claimTodo: (todoId, dryRun = false) => mutate('POST', `/api/todos/${encodeURIComponent(todoId)}/claim`, undefined, dryRun),
+        assignTodo: (todoId, assigneeId, dryRun = false) => mutate('POST', `/api/todos/${encodeURIComponent(todoId)}/assign`, { assignee_id: assigneeId }, dryRun),
+        createWorklog: (body, dryRun = false) => mutate('POST', '/api/work-logs', body, dryRun),
+        requestGet: (path, query) => client.get(path, query),
+    };
+}
+export function registerCollaborationCommands(program, groups, callbacks) {
+    const commands = createCollaborationCommands();
+    const action = (fn) => (...args) => {
+        Promise.resolve(fn(...args)).catch(callbacks.fatal);
+    };
+    const print = callbacks.print;
+    const projects = program.command('projects').description('Project discovery and context binding');
+    projects
+        .command('list')
+        .option('--keyword <text>')
+        .option('--page <number>', 'page number', Number)
+        .option('--page-size <number>', 'items per page', Number)
+        .option('--all', 'include inactive projects')
+        .option('--todo-stats')
+        .action(action(async (options) => print(await commands.listProjects({
+        keyword: options.keyword,
+        page: options.page,
+        page_size: options.pageSize,
+        activated_only: options.all ? false : undefined,
+        include_todo_stats: options.todoStats,
+    }))));
+    projects
+        .command('show <projectId>')
+        .option('--members')
+        .action(action(async (projectId, options) => print(await commands.showProject(projectId, Boolean(options.members)))));
+    projects
+        .command('resolve <query>')
+        .action(action(async (query) => print(await commands.resolveProject(query))));
+    program
+        .command('roster')
+        .description('Current team roster')
+        .command('list')
+        .option('--team <id>')
+        .action(action(async (options) => print(await commands.listRoster(options.team))));
+    const context = program.command('context').description('Viewer-scoped project context');
+    context
+        .command('get')
+        .option('--project <id>')
+        .option('--goal <id>')
+        .option('--person <id>')
+        .option('--query <text>', 'repeatable search term', collectOption, [])
+        .option('--section <name>', 'repeatable section filter', collectOption, [])
+        .option('--match <mode>', 'any|all|exact', 'any')
+        .option('--mode <mode>', 'brief|search', 'brief')
+        .option('--limit <number>', 'maximum context items', Number)
+        .action(action(async (options) => print(await commands.resolveContext({
+        project_id: options.project,
+        goal_id: options.goal,
+        person_id: options.person,
+        queries: options.query,
+        sections: options.section.length ? options.section : undefined,
+        match_mode: options.match,
+        mode: options.mode,
+        limit: options.limit,
+    }))));
+    context
+        .command('item <sourceType> <sourceId>')
+        .option('--project <id>')
+        .option('--goal <id>')
+        .option('--meeting <id>')
+        .option('--knowledge <id>')
+        .action(action(async (sourceType, sourceId, options) => print(await commands.getContextItem(sourceType, sourceId, {
+        project_id: options.project,
+        goal_id: options.goal,
+        meeting_id: options.meeting,
+        knowledge_id: options.knowledge,
+    }))));
+    groups.knowledge
+        .command('relations <knowledgeId>')
+        .action(action(async (knowledgeId) => print(await commands.relations(knowledgeId))));
+    groups.knowledge
+        .command('save [knowledgeId]')
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run')
+        .action(action(async (knowledgeId, options) => print(await commands.saveKnowledge(knowledgeId, await readJsonBody(options.bodyFile), Boolean(options.dryRun)))));
+    groups.knowledge
+        .command('attach <knowledgeId> <files...>')
+        .option('--dry-run')
+        .action(action(async (knowledgeId, files, options) => print(await commands.attachKnowledge(knowledgeId, files, Boolean(options.dryRun)))));
+    groups.knowledge
+        .command('attachment-content <knowledgeId> <attachmentId>')
+        .option('--truncate <characters>', 'maximum extracted text characters', Number)
+        .action(action(async (knowledgeId, attachmentId, options) => print(await commands.readKnowledgeAttachment(knowledgeId, attachmentId, options.truncate))));
+    groups.knowledge
+        .command('attachment-download <knowledgeId> <attachmentId>')
+        .option('--output <path>')
+        .option('--force')
+        .option('--dry-run')
+        .action(action(async (knowledgeId, attachmentId, options) => print(await commands.downloadKnowledgeAttachment(knowledgeId, attachmentId, options.output, Boolean(options.force), Boolean(options.dryRun)))));
+    const meetings = program.command('meetings').description('Meeting upload, minutes, knowledge, and project updates');
+    meetings
+        .command('list')
+        .option('--project <id>')
+        .option('--status <status>')
+        .option('--page <number>', 'page number', Number)
+        .option('--page-size <number>', 'items per page', Number)
+        .action(action(async (options) => print(await commands.listMeetings({
+        project_id: options.project,
+        status: options.status,
+        page: options.page,
+        page_size: options.pageSize,
+    }))));
+    meetings
+        .command('show <meetingId>')
+        .action(action(async (meetingId) => print(await commands.showMeeting(meetingId))));
+    for (const part of ['transcript', 'minutes', 'participants', 'processing']) {
+        meetings
+            .command(`${part} <meetingId>`)
+            .action(action(async (meetingId) => print(await commands.meetingPart(meetingId, part))));
+    }
+    meetings
+        .command('create')
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run')
+        .action(action(async (options) => print(await commands.createMeeting(await readJsonBody(options.bodyFile), Boolean(options.dryRun)))));
+    meetings
+        .command('upload <file>')
+        .requiredOption('--project <id>')
+        .option('--goal <id>')
+        .option('--title <text>')
+        .option('--dry-run')
+        .action(action(async (file, options) => print(await commands.uploadMeeting(file, options, Boolean(options.dryRun)))));
+    meetings
+        .command('retry <meetingId>')
+        .option('--dry-run')
+        .action(action(async (meetingId, options) => print(await commands.retryMeeting(meetingId, Boolean(options.dryRun)))));
+    meetings
+        .command('publish <meetingId>')
+        .option('--dry-run')
+        .action(action(async (meetingId, options) => print(await commands.publishMeetingKnowledge(meetingId, Boolean(options.dryRun)))));
+    meetings
+        .command('recording <meetingId>')
+        .option('--output <path>')
+        .option('--force')
+        .option('--dry-run')
+        .action(action(async (meetingId, options) => print(await commands.downloadMeetingRecording(meetingId, options.output, Boolean(options.force), Boolean(options.dryRun)))));
+    const updates = meetings.command('updates').description('Review meeting-derived project updates');
+    updates
+        .command('list <meetingId>')
+        .action(action(async (meetingId) => print(await commands.listProjectUpdates(meetingId))));
+    updates
+        .command('edit <meetingId> <updateId>')
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run')
+        .action(action(async (meetingId, updateId, options) => print(await commands.editProjectUpdate(meetingId, updateId, await readJsonBody(options.bodyFile), Boolean(options.dryRun)))));
+    updates
+        .command('confirm <meetingId> [updateIds...]')
+        .requiredOption('--knowledge <id>', 'published meeting knowledge id')
+        .option('--project <id>')
+        .option('--all', 'confirm every remaining draft update')
+        .option('--dry-run')
+        .action(action(async (meetingId, updateIds, options) => {
+        if (!updateIds.length && !options.all) {
+            throw new Error('Provide at least one update id, or pass --all after reviewing the draft list');
+        }
+        if (updateIds.length && options.all)
+            throw new Error('Use explicit update ids or --all, not both');
+        print(await commands.confirmProjectUpdates(meetingId, updateIds, options.project, options.knowledge, Boolean(options.dryRun)));
+    }));
+    updates
+        .command('ignore <meetingId> <updateId>')
+        .option('--dry-run')
+        .action(action(async (meetingId, updateId, options) => print(await commands.ignoreProjectUpdate(meetingId, updateId, Boolean(options.dryRun)))));
+    registerJsonMutation(groups.goals, 'create', [], (args, body, dryRun) => commands.createGoal(body, dryRun), action, print);
+    registerJsonMutation(groups.goals, 'update <goalId>', ['goalId'], (args, body, dryRun) => commands.updateGoal(args.goalId, body, dryRun), action, print);
+    registerJsonMutation(groups.goals, 'submit-review <goalId>', ['goalId'], (args, body, dryRun) => commands.submitGoalReview(args.goalId, body, dryRun), action, print);
+    registerJsonMutation(groups.goals, 'review <goalId>', ['goalId'], (args, body, dryRun) => commands.reviewGoal(args.goalId, body, dryRun), action, print);
+    registerJsonMutation(groups.todos, 'create', [], (args, body, dryRun) => commands.createTodo(body, dryRun), action, print);
+    registerJsonMutation(groups.todos, 'update <todoId>', ['todoId'], (args, body, dryRun) => commands.updateTodo(args.todoId, body, dryRun), action, print);
+    registerJsonMutation(groups.todos, 'submit-review <todoId>', ['todoId'], (args, body, dryRun) => commands.submitTodoReview(args.todoId, body, dryRun), action, print);
+    registerJsonMutation(groups.todos, 'review <todoId>', ['todoId'], (args, body, dryRun) => commands.reviewTodo(args.todoId, body, dryRun), action, print);
+    groups.todos
+        .command('claim <todoId>')
+        .option('--dry-run')
+        .action(action(async (todoId, options) => print(await commands.claimTodo(todoId, Boolean(options.dryRun)))));
+    groups.todos
+        .command('assign <todoId> <assigneeId>')
+        .option('--dry-run')
+        .action(action(async (todoId, assigneeId, options) => print(await commands.assignTodo(todoId, assigneeId, Boolean(options.dryRun)))));
+    registerJsonMutation(groups.worklogs, 'create', [], (args, body, dryRun) => commands.createWorklog(body, dryRun), action, print);
+    program
+        .command('request')
+        .description('Read-only raw API escape hatch')
+        .command('get <path>')
+        .option('--query <key=value>', 'repeatable query parameter', collectOption, [])
+        .action(action(async (path, options) => {
+        if (!path.startsWith('/api/'))
+            throw new Error('Raw request paths must start with /api/');
+        print(await commands.requestGet(path, parseKeyValueOptions(options.query)));
+    }));
+}
+function registerJsonMutation(parent, name, argumentNames, execute, action, print) {
+    const command = parent
+        .command(name)
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run');
+    command.action(action(async (...values) => {
+        const options = values[argumentNames.length];
+        const args = Object.fromEntries(argumentNames.map((argument, index) => [argument, String(values[index])]));
+        print(await execute(args, await readJsonBody(options.bodyFile), Boolean(options.dryRun)));
+    }));
+}
+function dryRunRequest(method, path, body) {
+    return {
+        dry_run: true,
+        request: {
+            method,
+            path,
+            ...(body === undefined ? {} : { body }),
+        },
+    };
+}
+function dryRunDownload(path, output, force) {
+    return {
+        dry_run: true,
+        request: { method: 'GET', path },
+        output: { path: output || null, force },
+    };
+}

package/dist/commands/hook.js

@@ -0,0 +1,162 @@
+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/commands/resources.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ApiClient, listQuery } from '../core/api-client.js';
+import { readAuth } from '../core/auth.js';
+import { initProjectStore, listEvents } from '../core/store.js';
+export function createResourceCommands(client = new ApiClient()) {
+    return {
+        async listGoals(options) {
+            return client.get('/api/goals', listQuery(options));
+        },
+        async showGoal(goalId) {
+            return client.get(`/api/goals/${encodeURIComponent(goalId)}`);
+        },
+        async listTodos(options) {
+            return client.get('/api/todos', listQuery(options));
+        },
+        async showTodo(todoId) {
+            return client.get(`/api/todos/${encodeURIComponent(todoId)}`);
+        },
+        async updateTodoStatus(todoId, status) {
+            return client.patch(`/api/todos/${encodeURIComponent(todoId)}/status`, { status });
+        },
+        async updateTodoProgress(todoId, message) {
+            return client.patch(`/api/todos/${encodeURIComponent(todoId)}/progress-description`, {
+                progress_description: message,
+            });
+        },
+        async listKnowledge(options) {
+            return client.get('/api/memory/objects', knowledgeQuery(options));
+        },
+        async showKnowledge(knowledgeId) {
+            return client.get(`/api/memory/objects/${encodeURIComponent(knowledgeId)}`);
+        },
+        async searchKnowledge(keyword, options = {}) {
+            return client.get('/api/memory/search', listQuery({
+                q: keyword,
+                project_id: options.project,
+                person: options.person,
+                scope: options.scope,
+                limit: options.limit,
+            }));
+        },
+        async listKnowledgeSources(options) {
+            return client.get('/api/gitea/knowledge', listQuery({ path: options.path, q: options.q }));
+        },
+        async readKnowledgeSource(filePath) {
+            return client.get(`/api/gitea/knowledge/${encodeURIComponent(filePath)}`);
+        },
+        async listWorklogs(options) {
+            return client.get('/api/work-logs', listQuery(options));
+        },
+        async recordWorklog(summary, type = 'note') {
+            return client.post('/api/work-logs', {
+                summary,
+                event_type: type,
+                source: 'manual',
+                metadata: { source_client: 'ot-cli' },
+            });
+        },
+    };
+}
+function knowledgeQuery(options) {
+    return listQuery({
+        type: 'knowledge',
+        project_id: options.project_id || options.project,
+        q: options.q,
+        kind: options.kind,
+        status: options.status,
+        space: options.space,
+        person: options.person,
+        page: options.page,
+        page_size: options.pageSize,
+    });
+}
+export function draftDailyReport(workspace, options = {}) {
+    const store = initProjectStore(workspace);
+    const events = listEvents(store, 500);
+    const date = new Date().toISOString().slice(0, 10);
+    const lines = [
+        `# ${date} 工作日报草稿`,
+        '',
+        '## 今日记录',
+        '',
+        ...events.map((event) => `- ${event.occurred_at} [${event.source}/${event.type}] ${event.summary || ''}`),
+        '',
+        '## 提交与工具调用摘要',
+        '',
+        '请结合上述记录补充业务语义、风险和明日计划。',
+        '',
+    ];
+    const content = lines.join('\n');
+    const outputPath = options.output || path.join(store.dir, 'drafts', `${date}.md`);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, content, 'utf-8');
+    return outputPath;
+}
+export function doctor(workspace, target) {
+    const auth = readAuth();
+    const store = initProjectStore(workspace);
+    const projectDirExists = fs.existsSync(store.dir);
+    return {
+        cli: {
+            project_dir: store.dir,
+            project_dir_exists: projectDirExists,
+            global_dir: path.join(process.env.HOME || '', '.openturtle', 'cli'),
+            mcp_server_name: 'ot-cli',
+        },
+        auth: {
+            server: auth.server || null,
+            token_configured: Boolean(auth.token),
+        },
+        coexistence: {
+            avoids_project_dot_openturtle: true,
+            desktop_mcp_names_reserved: ['openturtle-knowledge', 'openturtle-automations', 'openturtle-todo'],
+        },
+        target: target || 'all',
+    };
+}