@openturtle/cli 0.3.0

package/dist/core/api-client.js

@@ -0,0 +1,221 @@
+import fs from 'node:fs';
+import nodePath from 'node:path';
+import { readAuth, writeAuth } from './auth.js';
+import { DEFAULT_SERVER_URL } from './defaults.js';
+export class ApiError extends Error {
+    method;
+    path;
+    status;
+    detail;
+    code = 'api_error';
+    constructor(message, method, path, status, detail) {
+        super(message);
+        this.method = method;
+        this.path = path;
+        this.status = status;
+        this.detail = detail;
+        this.name = 'ApiError';
+    }
+}
+export class ApiClient {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async request(method, path, body, query) {
+        const { url, token } = this.requestContext(path, query);
+        const response = await this.fetchResponse(method, url, {
+            headers: {
+                ...(body == null ? {} : { 'content-type': 'application/json' }),
+                ...(token ? { authorization: `Bearer ${token}` } : {}),
+            },
+            ...(body == null ? {} : { body: JSON.stringify(body) }),
+        });
+        return this.parseResponse(method, url, response);
+    }
+    get(path, query) {
+        return this.request('GET', path, undefined, query);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    delete(path, body) {
+        return this.request('DELETE', path, body);
+    }
+    async upload(method, pathname, files, fields = {}) {
+        const form = new FormData();
+        for (const [key, value] of Object.entries(fields)) {
+            if (value == null || value === '')
+                continue;
+            form.append(key, typeof value === 'string' ? value : JSON.stringify(value));
+        }
+        for (const file of files) {
+            if (!fs.existsSync(file.filePath) || !fs.statSync(file.filePath).isFile()) {
+                throw new Error(`File not found: ${file.filePath}`);
+            }
+            const bytes = fs.readFileSync(file.filePath);
+            form.append(file.field, new Blob([bytes], { type: contentTypeFor(file.filePath) }), nodePath.basename(file.filePath));
+        }
+        const { url, token } = this.requestContext(pathname);
+        const response = await this.fetchResponse(method, url, {
+            headers: token ? { authorization: `Bearer ${token}` } : {},
+            body: form,
+        });
+        return this.parseResponse(method, url, response);
+    }
+    async download(pathname, outputPath, force = false) {
+        const { url, token } = this.requestContext(pathname);
+        const response = await this.fetchResponse('GET', url, {
+            headers: token ? { authorization: `Bearer ${token}` } : {},
+        });
+        if (!response.ok)
+            return this.parseResponse('GET', url, response);
+        const filename = responseFilename(response) || 'download';
+        const resolvedOutput = nodePath.resolve(outputPath || filename);
+        if (fs.existsSync(resolvedOutput) && !force) {
+            throw new Error(`Refusing to overwrite existing file: ${resolvedOutput}. Pass --force to replace it.`);
+        }
+        fs.mkdirSync(nodePath.dirname(resolvedOutput), { recursive: true });
+        const bytes = Buffer.from(await response.arrayBuffer());
+        fs.writeFileSync(resolvedOutput, bytes);
+        return {
+            downloaded: true,
+            path: resolvedOutput,
+            bytes: bytes.length,
+            content_type: response.headers.get('content-type'),
+        };
+    }
+    async probe(path = '/api/teams/me') {
+        const { url, token, server } = this.requestContext(path);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: token ? { authorization: `Bearer ${token}` } : {},
+            });
+            return {
+                server,
+                reachable: true,
+                authenticated: response.ok,
+                status: response.status,
+            };
+        }
+        catch (error) {
+            return {
+                server,
+                reachable: false,
+                authenticated: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async loginWithToken(server, token) {
+        writeAuth({ server, token }, this.options.homeDir);
+    }
+    requestContext(pathname, query) {
+        const auth = readAuth(this.options.homeDir);
+        const server = normalizeServerUrl(this.options.server || auth.server || DEFAULT_SERVER_URL);
+        const token = this.options.token || auth.token;
+        const url = resolveApiUrl(server, pathname);
+        for (const [key, value] of Object.entries(query || {})) {
+            if (value == null || value === '')
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    url.searchParams.append(key, String(item));
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return { url, token, server };
+    }
+    async fetchResponse(method, url, init) {
+        try {
+            return await fetch(url, { ...init, method });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new ApiError(`${method} ${url.pathname} failed: ${detail}`, method, url.pathname, 0, detail);
+        }
+    }
+    async parseResponse(method, url, response) {
+        if (!response.ok) {
+            const raw = await response.text().catch(() => '');
+            let detail = raw;
+            try {
+                detail = raw ? JSON.parse(raw) : undefined;
+            }
+            catch {
+                // Keep non-JSON error payloads as text.
+            }
+            const summary = errorSummary(detail);
+            throw new ApiError(`${method} ${url.pathname} failed: ${response.status}${summary ? ` ${summary}` : ''}`, method, url.pathname, response.status, detail);
+        }
+        if (response.status === 204)
+            return undefined;
+        const text = await response.text();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+}
+export function resolveApiUrl(server, pathname) {
+    const baseUrl = new URL(normalizeServerUrl(server));
+    baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, '')}/`;
+    return new URL(pathname.replace(/^\/+/, ''), baseUrl);
+}
+function normalizeServerUrl(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/+$/, '') || '/';
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/, '');
+}
+export function listQuery(options) {
+    return Object.fromEntries(Object.entries(options).filter(([, value]) => value != null && value !== ''));
+}
+function errorSummary(detail) {
+    if (typeof detail === 'string')
+        return detail;
+    if (detail && typeof detail === 'object' && 'detail' in detail) {
+        const value = detail.detail;
+        return typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    return detail == null ? '' : JSON.stringify(detail);
+}
+function contentTypeFor(filePath) {
+    const extension = nodePath.extname(filePath).toLowerCase();
+    return ({
+        '.json': 'application/json',
+        '.md': 'text/markdown',
+        '.txt': 'text/plain',
+        '.pdf': 'application/pdf',
+        '.wav': 'audio/wav',
+        '.mp3': 'audio/mpeg',
+        '.m4a': 'audio/mp4',
+        '.ogg': 'audio/ogg',
+        '.webm': 'audio/webm',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+    }[extension] || 'application/octet-stream');
+}
+function responseFilename(response) {
+    const disposition = response.headers.get('content-disposition') || '';
+    const encoded = disposition.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+    if (encoded)
+        return nodePath.basename(decodeURIComponent(encoded));
+    const quoted = disposition.match(/filename="([^"]+)"/i)?.[1];
+    if (quoted)
+        return nodePath.basename(quoted);
+    const plain = disposition.match(/filename=([^;]+)/i)?.[1]?.trim();
+    return plain ? nodePath.basename(plain) : undefined;
+}

package/dist/core/auth.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cliGlobalDir } from './paths.js';
+import { readJsonFile, writeJsonFile } from './json.js';
+export function authPath(homeDir = os.homedir()) {
+    return path.join(cliGlobalDir(homeDir), 'auth.json');
+}
+export function readAuth(homeDir = os.homedir()) {
+    const envToken = process.env.OPENTURTLE_TOKEN;
+    const envServer = process.env.OPENTURTLE_SERVER_URL || process.env.SERVER_URL;
+    const config = readJsonFile(authPath(homeDir), {});
+    return {
+        ...config,
+        ...(envServer ? { server: envServer } : {}),
+        ...(envToken ? { token: envToken } : {}),
+    };
+}
+export function writeAuth(config, homeDir = os.homedir()) {
+    const filePath = authPath(homeDir);
+    writeJsonFile(filePath, config);
+    fs.chmodSync(filePath, 0o600);
+}
+export function clearAuth(homeDir = os.homedir()) {
+    const filePath = authPath(homeDir);
+    if (fs.existsSync(filePath))
+        fs.unlinkSync(filePath);
+}
+export function redactToken(token) {
+    if (!token)
+        return undefined;
+    if (token.length <= 8)
+        return '***';
+    return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}

package/dist/core/defaults.js

@@ -0,0 +1 @@
+export const DEFAULT_SERVER_URL = 'https://lavertest.kingdee.com/openturtle';

package/dist/core/input.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+export async function readJsonBody(filePath) {
+    if (!filePath)
+        throw new Error('Missing required option --body-file');
+    const text = filePath === '-' ? await readStdin() : fs.readFileSync(filePath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON in ${filePath}: ${detail}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`JSON body in ${filePath} must be an object`);
+    }
+    return parsed;
+}
+export function collectOption(value, previous) {
+    return [...previous, value];
+}
+export function parseKeyValueOptions(values) {
+    const result = {};
+    for (const value of values) {
+        const separator = value.indexOf('=');
+        if (separator <= 0)
+            throw new Error(`Expected key=value, received: ${value}`);
+        result[value.slice(0, separator)] = value.slice(separator + 1);
+    }
+    return result;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf-8');
+}

package/dist/core/json.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import { ensureFileDir } from './paths.js';
+export function readJsonFile(filePath, fallback) {
+    if (!fs.existsSync(filePath))
+        return fallback;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+export function writeJsonFile(filePath, value) {
+    ensureFileDir(filePath);
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+export function parseJsonObject(value) {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : { value: parsed };
+}
+export function compactJson(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/core/managed-block.js

@@ -0,0 +1,25 @@
+export const MANAGED_MARKER = 'OPENTURTLE-CLI';
+export function managedHeader(id) {
+    return `# >>> ${MANAGED_MARKER}:${id}`;
+}
+export function managedFooter(id) {
+    return `# <<< ${MANAGED_MARKER}:${id}`;
+}
+export function replaceManagedBlock(content, id, block) {
+    const header = managedHeader(id);
+    const footer = managedFooter(id);
+    const normalizedBlock = [header, block.trimEnd(), footer].join('\n');
+    const pattern = new RegExp(`${escapeRegExp(header)}[\\s\\S]*?${escapeRegExp(footer)}\\n?`, 'm');
+    const trimmed = content.trimEnd();
+    if (pattern.test(content)) {
+        return `${content.replace(pattern, `${normalizedBlock}\n`).trimEnd()}\n`;
+    }
+    return `${[trimmed, normalizedBlock].filter(Boolean).join('\n\n')}\n`;
+}
+export function removeManagedBlock(content, id) {
+    const pattern = new RegExp(`${escapeRegExp(managedHeader(id))}[\\s\\S]*?${escapeRegExp(managedFooter(id))}\\n?`, 'm');
+    return `${content.replace(pattern, '').trimEnd()}\n`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/core/mcp-config.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readJsonFile, writeJsonFile } from './json.js';
+import { ensureFileDir } from './paths.js';
+export const MCP_SERVER_NAME = 'ot-cli';
+export function otMcpConfig() {
+    return { command: 'ot', args: ['mcp', 'serve'], enabled: true };
+}
+export function mergeJsonMcpServer(filePath, name = MCP_SERVER_NAME) {
+    const parsed = readJsonFile(filePath, {});
+    const servers = parsed.mcpServers && typeof parsed.mcpServers === 'object'
+        ? parsed.mcpServers
+        : {};
+    servers[name] = otMcpConfig();
+    writeJsonFile(filePath, { ...parsed, mcpServers: servers });
+}
+export function removeJsonMcpServer(filePath, name = MCP_SERVER_NAME, pruneStopDir) {
+    if (!fs.existsSync(filePath))
+        return;
+    const parsed = readJsonFile(filePath, {});
+    const servers = parsed.mcpServers && typeof parsed.mcpServers === 'object'
+        ? { ...parsed.mcpServers }
+        : {};
+    delete servers[name];
+    const next = { ...parsed, mcpServers: servers };
+    if (Object.keys(servers).length === 0)
+        delete next.mcpServers;
+    if (Object.keys(next).length === 0) {
+        fs.rmSync(filePath, { force: true });
+        pruneEmptyParents(path.dirname(filePath), pruneStopDir);
+        return;
+    }
+    writeJsonFile(filePath, next);
+}
+export function claudeMcpPath(scope, workspace, homeDir = os.homedir()) {
+    return scope === 'user'
+        ? path.join(homeDir, '.claude', 'mcp_servers.json')
+        : path.join(workspace, '.claude', 'mcp_servers.json');
+}
+export function claudeSettingsPath(scope, workspace, homeDir = os.homedir()) {
+    return scope === 'user'
+        ? path.join(homeDir, '.claude', 'settings.json')
+        : path.join(workspace, '.claude', 'settings.json');
+}
+export function codexConfigPath(scope, workspace, homeDir = os.homedir()) {
+    return scope === 'user' ? path.join(homeDir, '.codex', 'config.toml') : path.join(workspace, '.codex', 'config.toml');
+}
+export function cursorMcpPath(workspace) {
+    return path.join(workspace, '.mcp.json');
+}
+export function qoderMcpPath(scope, workspace, homeDir = os.homedir()) {
+    return scope === 'user' ? path.join(homeDir, '.qoder.json') : path.join(workspace, '.mcp.json');
+}
+export function kiroMcpPath(scope, workspace, homeDir = os.homedir()) {
+    return scope === 'user'
+        ? path.join(homeDir, '.kiro', 'settings', 'mcp.json')
+        : path.join(workspace, '.kiro', 'settings', 'mcp.json');
+}
+export function mergeCodexMcpServer(filePath) {
+    ensureFileDir(filePath);
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    const withoutServer = stripTomlTable(existing, `mcp_servers.${MCP_SERVER_NAME}`);
+    const block = [
+        `[mcp_servers.${MCP_SERVER_NAME}]`,
+        `command = "ot"`,
+        `args = ["mcp", "serve"]`,
+        `enabled = true`,
+    ].join('\n');
+    fs.writeFileSync(filePath, `${[withoutServer.trimEnd(), block].filter(Boolean).join('\n\n')}\n`, 'utf-8');
+}
+export function appendCodexHookBlocks(filePath, hookBlocks) {
+    ensureFileDir(filePath);
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    const cleaned = removeManagedTomlBlock(existing, 'hooks');
+    const block = [`# >>> OPENTURTLE-CLI:hooks`, hookBlocks.trimEnd(), `# <<< OPENTURTLE-CLI:hooks`].join('\n');
+    fs.writeFileSync(filePath, `${[cleaned.trimEnd(), block].filter(Boolean).join('\n\n')}\n`, 'utf-8');
+}
+export function removeCodexManagedConfig(filePath, pruneStopDir) {
+    if (!fs.existsSync(filePath))
+        return;
+    const existing = fs.readFileSync(filePath, 'utf-8');
+    const withoutHooks = removeManagedTomlBlock(existing, 'hooks');
+    const withoutServer = stripTomlTable(withoutHooks, `mcp_servers.${MCP_SERVER_NAME}`);
+    const next = withoutServer.trim();
+    if (!next) {
+        fs.rmSync(filePath, { force: true });
+        pruneEmptyParents(path.dirname(filePath), pruneStopDir);
+        return;
+    }
+    fs.writeFileSync(filePath, `${next}\n`, 'utf-8');
+}
+function removeManagedTomlBlock(content, id) {
+    return content.replace(new RegExp(`\\n?# >>> OPENTURTLE-CLI:${id}[\\s\\S]*?# <<< OPENTURTLE-CLI:${id}\\r?\\n?`, 'm'), '');
+}
+function stripTomlTable(content, tableName) {
+    const lines = content.split(/\r?\n/);
+    const kept = [];
+    let skipping = false;
+    const tablePattern = new RegExp(`^\\s*\\[${escapeRegExp(tableName)}\\]\\s*$`);
+    for (const line of lines) {
+        if (/^\s*\[/.test(line)) {
+            skipping = tablePattern.test(line);
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    return kept.join('\n');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function pruneEmptyParents(startDir, stopDir) {
+    let current = startDir;
+    const stop = stopDir ? path.resolve(stopDir) : undefined;
+    for (let index = 0; index < 3; index += 1) {
+        try {
+            if (stop && path.resolve(current) === stop)
+                return;
+            if (!fs.existsSync(current) || fs.readdirSync(current).length > 0)
+                return;
+            fs.rmdirSync(current);
+            current = path.dirname(current);
+        }
+        catch {
+            return;
+        }
+    }
+}

package/dist/core/paths.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const PROJECT_DIR_NAME = '.openturtle-cli';
+export const GLOBAL_DIR_PARTS = ['.openturtle', 'cli'];
+export function cliGlobalDir(homeDir = os.homedir()) {
+    return path.join(homeDir, ...GLOBAL_DIR_PARTS);
+}
+export function projectWorklogDir(workspacePath) {
+    return path.join(workspacePath, PROJECT_DIR_NAME);
+}
+export function findWorkspaceRoot(startPath = process.cwd()) {
+    let current = path.resolve(startPath);
+    if (fs.existsSync(current) && fs.statSync(current).isFile()) {
+        current = path.dirname(current);
+    }
+    for (;;) {
+        if (fs.existsSync(path.join(current, PROJECT_DIR_NAME)) || fs.existsSync(path.join(current, '.git'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return path.resolve(startPath);
+        current = parent;
+    }
+}
+export function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+export function ensureFileDir(filePath) {
+    ensureDir(path.dirname(filePath));
+}

package/dist/core/store.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { projectWorklogDir } from './paths.js';
+export function initProjectStore(workspacePath) {
+    const workspace = path.resolve(workspacePath);
+    const dir = projectWorklogDir(workspace);
+    fs.mkdirSync(path.join(dir, 'hooks'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'drafts'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'cache'), { recursive: true });
+    const configPath = path.join(dir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, `${JSON.stringify({
+            version: 1,
+            mcpServerName: 'ot-cli',
+            createdAt: new Date().toISOString(),
+        }, null, 2)}\n`, 'utf-8');
+    }
+    const db = createDatabase(path.join(dir, 'state.db'));
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 2000');
+    migrate(db);
+    return { workspace, dir, db };
+}
+function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      source TEXT NOT NULL,
+      source_id TEXT,
+      workspace_path TEXT,
+      summary TEXT,
+      raw_json TEXT,
+      occurred_at TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      dedupe_key TEXT NOT NULL UNIQUE
+    );
+
+    CREATE TABLE IF NOT EXISTS hook_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      target TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      exit_code INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      raw_input_json TEXT,
+      error TEXT,
+      occurred_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS commits (
+      hash TEXT PRIMARY KEY,
+      message TEXT,
+      author TEXT,
+      diff_stat TEXT,
+      changed_files_json TEXT,
+      occurred_at TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      kind TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_error TEXT
+    );
+  `);
+}
+function createDatabase(filePath) {
+    const require = createRequire(import.meta.url);
+    const sqlite = require('node:sqlite');
+    return new sqlite.DatabaseSync(filePath);
+}
+export function upsertEvent(store, event) {
+    const occurredAt = event.occurredAt || new Date().toISOString();
+    const result = store.db
+        .prepare(`INSERT OR IGNORE INTO events
+        (type, source, source_id, workspace_path, summary, raw_json, occurred_at, dedupe_key)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(event.type, event.source, event.sourceId || null, event.workspacePath || null, event.summary || null, event.rawJson == null ? null : JSON.stringify(event.rawJson), occurredAt, event.dedupeKey);
+    return { inserted: result.changes > 0 };
+}
+export function recordHookRun(store, run) {
+    store.db
+        .prepare(`INSERT INTO hook_runs
+        (target, event_type, exit_code, duration_ms, raw_input_json, error, occurred_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(run.target, run.eventType, run.exitCode, run.durationMs, run.rawInputJson || null, run.error || null, run.occurredAt || new Date().toISOString());
+}
+export function listEvents(store, limit = 100) {
+    return store.db
+        .prepare('SELECT * FROM events ORDER BY occurred_at ASC, id ASC LIMIT ?')
+        .all(limit);
+}
+export function recordCommit(store, commit) {
+    store.db
+        .prepare(`INSERT OR REPLACE INTO commits
+        (hash, message, author, diff_stat, changed_files_json, occurred_at)
+       VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(commit.hash, commit.message || '', commit.author || '', commit.diffStat || '', JSON.stringify(commit.changedFiles || []), commit.occurredAt || new Date().toISOString());
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/version.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const packageJsonPath = fileURLToPath(new URL('../../package.json', import.meta.url));
+export function cliVersion() {
+    const metadata = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    if (!metadata.version)
+        throw new Error('CLI package version is missing');
+    return metadata.version;
+}
+export function nextReleaseVersion(repositoryVersion, publishedVersion) {
+    const repository = parseStableVersion(repositoryVersion);
+    if (!publishedVersion)
+        return formatVersion(repository);
+    const published = parseStableVersion(publishedVersion);
+    const nextPublished = { ...published, patch: published.patch + 1 };
+    return formatVersion(compareVersions(repository, nextPublished) > 0 ? repository : nextPublished);
+}
+function parseStableVersion(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value.trim());
+    if (!match)
+        throw new Error(`Expected a stable semantic version, received: ${value}`);
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+function compareVersions(left, right) {
+    return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
+}
+function formatVersion(version) {
+    return `${version.major}.${version.minor}.${version.patch}`;
+}