agent-remnote 0.1.0 → 0.3.0

package/dist/apps/cli/src/services/RefResolver.js

@@ -1,111 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { executeSearchRemOverview } from '../adapters/mcp.js';
-import { AppConfig } from './AppConfig.js';
-import { CliError } from './Errors.js';
-export class RefResolver extends Context.Tag('RefResolver')() {
-}
-function stripQuotes(s) {
-    const t = s.trim();
-    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
-        return t.slice(1, -1);
-    }
-    return t;
-}
-function parseRef(input) {
-    const raw = input.trim();
-    const idx = raw.indexOf(':');
-    if (idx <= 0) {
-        throw new CliError({
-            code: 'INVALID_ARGS',
-            message: `ref 不合法：${input}`,
-            exitCode: 2,
-            hint: ['示例：--ref id:xxx', '示例：--ref title:Demo', '示例：--ref daily:today', '示例：--ref daily:-1'],
-        });
-    }
-    const kind = raw.slice(0, idx).trim();
-    const value = stripQuotes(raw.slice(idx + 1));
-    if (!value) {
-        throw new CliError({
-            code: 'INVALID_ARGS',
-            message: `ref 不合法（缺少值）：${input}`,
-            exitCode: 2,
-        });
-    }
-    if (kind === 'id' || kind === 'title' || kind === 'daily') {
-        return { kind, value };
-    }
-    throw new CliError({
-        code: 'INVALID_ARGS',
-        message: `ref 不支持：${input}`,
-        exitCode: 2,
-        hint: ['支持：id:/title:/daily:'],
-    });
-}
-function parseDailyOffset(value) {
-    const v = value.trim().toLowerCase();
-    if (v === 'today' || v === 'now' || v === '0')
-        return 0;
-    if (v === 'yesterday')
-        return -1;
-    if (v === 'tomorrow')
-        return 1;
-    const n = Number.parseInt(v, 10);
-    if (!Number.isFinite(n)) {
-        throw new CliError({
-            code: 'INVALID_ARGS',
-            message: `daily ref 不合法：${value}（需要 today/yesterday/tomorrow 或整数偏移）`,
-            exitCode: 2,
-        });
-    }
-    return n;
-}
-export const RefResolverLive = Layer.succeed(RefResolver, {
-    resolve: (ref) => Effect.gen(function* () {
-        const cfg = yield* AppConfig;
-        const parsed = yield* Effect.try({
-            try: () => parseRef(ref),
-            catch: (e) => e && typeof e === 'object' && e._tag === 'CliError'
-                ? e
-                : new CliError({ code: 'INVALID_ARGS', message: `ref 不合法：${ref}`, exitCode: 2 }),
-        });
-        if (parsed.kind === 'id')
-            return parsed.value;
-        const dailyOffset = parsed.kind === 'daily'
-            ? yield* Effect.try({
-                try: () => parseDailyOffset(parsed.value),
-                catch: (e) => e && typeof e === 'object' && e._tag === 'CliError'
-                    ? e
-                    : new CliError({ code: 'INVALID_ARGS', message: `daily ref 不合法：${parsed.value}`, exitCode: 2 }),
-            })
-            : undefined;
-        const queryInput = parsed.kind === 'title'
-            ? { query: parsed.value }
-            : { query: 'date', useCurrentDate: true, dateOffsetDays: dailyOffset };
-        const result = yield* Effect.tryPromise({
-            try: async () => await executeSearchRemOverview({
-                ...queryInput,
-                dbPath: cfg.remnoteDb,
-                limit: 1,
-                preferExact: true,
-                exactFirstSingle: true,
-            }),
-            catch: (e) => new CliError({
-                code: 'DB_UNAVAILABLE',
-                message: String(e?.message || e || 'RemNote DB 不可用'),
-                exitCode: 1,
-            }),
-        });
-        const first = Array.isArray(result.matches) ? result.matches[0] : undefined;
-        const id = first?.id ? String(first.id) : '';
-        if (!id) {
-            return yield* Effect.fail(new CliError({
-                code: 'INVALID_ARGS',
-                message: `未找到 ref 对应的 Rem：${ref}`,
-                exitCode: 2,
-            }));
-        }
-        return id;
-    }),
-});

package/dist/apps/cli/src/services/RemDb.js

@@ -1,35 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { CliError, isCliError } from './Errors.js';
-import { discoverBackups, withResolvedDatabase } from '../adapters/mcp.js';
-export class RemDb extends Context.Tag('RemDb')() {
-}
-export const RemDbLive = Layer.succeed(RemDb, {
-    withDb: (dbPath, fn) => Effect.tryPromise({
-        try: async () => await withResolvedDatabase(dbPath, fn),
-        catch: (error) => {
-            if (isCliError(error))
-                return error;
-            return new CliError({
-                code: 'DB_UNAVAILABLE',
-                message: String(error?.message || error || 'RemNote DB 不可用'),
-                exitCode: 1,
-                details: { db_path: dbPath },
-            });
-        },
-    }),
-    backups: (basePath) => Effect.tryPromise({
-        try: async () => await discoverBackups(basePath),
-        catch: (error) => {
-            if (isCliError(error))
-                return error;
-            return new CliError({
-                code: 'DB_UNAVAILABLE',
-                message: String(error?.message || error || '无法读取 RemNote 备份目录'),
-                exitCode: 1,
-                details: { base_path: basePath },
-            });
-        },
-    }),
-});

package/dist/apps/cli/src/services/WsClient.js

@@ -1,170 +0,0 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import WebSocket from 'ws';
-import { CliError } from './Errors.js';
-export class WsClient extends Context.Tag('WsClient')() {
-}
-function formatError(e) {
-    if (!e)
-        return 'unknown error';
-    if (typeof e === 'string')
-        return e;
-    const anyErr = e;
-    if (anyErr?.errors && Array.isArray(anyErr.errors)) {
-        const parts = anyErr.errors
-            .map((inner) => {
-            const code = inner?.code ? String(inner.code) : '';
-            const msg = inner?.message ? String(inner.message) : String(inner);
-            return code ? `${code}: ${msg}` : msg;
-        })
-            .filter(Boolean);
-        if (parts.length > 0)
-            return `AggregateError(${parts.join('; ')})`;
-    }
-    if (typeof anyErr?.message === 'string')
-        return anyErr.message;
-    return String(e);
-}
-function connectOnce(params) {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(params.url);
-        let done = false;
-        const finishOk = () => {
-            if (done)
-                return;
-            done = true;
-            clearTimeout(timer);
-            try {
-                ws.terminate();
-            }
-            catch (_) { }
-            resolve();
-        };
-        const finishErr = (error) => {
-            if (done)
-                return;
-            done = true;
-            clearTimeout(timer);
-            try {
-                ws.terminate();
-            }
-            catch (_) { }
-            reject(error);
-        };
-        const timer = setTimeout(() => {
-            finishErr(new Error(`timeout after ${params.timeoutMs}ms`));
-        }, params.timeoutMs);
-        ws.on('open', () => {
-            try {
-                params.onOpen(ws);
-            }
-            catch (e) {
-                finishErr(e);
-            }
-        });
-        ws.on('message', (data) => {
-            try {
-                const txt = String(data);
-                const msg = JSON.parse(txt);
-                params.onMessage(ws, msg);
-            }
-            catch (_) {
-                // ignore non-json
-            }
-        });
-        ws.on('error', (e) => {
-            finishErr(e);
-        });
-        ws.on('close', () => {
-            finishErr(new Error('connection closed'));
-        });
-        ws.__finishOk = finishOk;
-    });
-}
-export const WsClientLive = Layer.succeed(WsClient, {
-    health: ({ url, timeoutMs }) => Effect.tryPromise({
-        try: async () => {
-            const startedAt = Date.now();
-            await connectOnce({
-                url,
-                timeoutMs,
-                onOpen: (ws) => {
-                    ws.send(JSON.stringify({ type: 'Hello' }));
-                },
-                onMessage: (ws, msg) => {
-                    if (msg?.type === 'HelloAck' && msg?.ok === true) {
-                        ;
-                        ws.__finishOk?.();
-                    }
-                },
-            });
-            return { url, rtt_ms: Date.now() - startedAt };
-        },
-        catch: (error) => {
-            const message = formatError(error);
-            return new CliError({
-                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
-                message,
-                exitCode: 1,
-                details: { url, timeout_ms: timeoutMs },
-            });
-        },
-    }),
-    triggerStartSync: ({ url, timeoutMs, consumerId }) => Effect.tryPromise({
-        try: async () => {
-            let result;
-            await connectOnce({
-                url,
-                timeoutMs,
-                onOpen: (ws) => {
-                    ws.send(JSON.stringify({ type: 'TriggerStartSync', consumerId }));
-                },
-                onMessage: (ws, msg) => {
-                    if (msg?.type === 'StartSyncTriggered') {
-                        result = { sent: typeof msg?.sent === 'number' ? msg.sent : 0 };
-                        ws.__finishOk?.();
-                    }
-                },
-            });
-            return result ?? { sent: 0 };
-        },
-        catch: (error) => {
-            const message = formatError(error);
-            return new CliError({
-                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
-                message,
-                exitCode: 1,
-                details: { url, timeout_ms: timeoutMs, consumer_id: consumerId },
-            });
-        },
-    }),
-    queryClients: ({ url, timeoutMs }) => Effect.tryPromise({
-        try: async () => {
-            let result;
-            await connectOnce({
-                url,
-                timeoutMs,
-                onOpen: (ws) => {
-                    ws.send(JSON.stringify({ type: 'QueryClients' }));
-                },
-                onMessage: (ws, msg) => {
-                    if (msg?.type === 'Clients' && Array.isArray(msg?.clients)) {
-                        result = { clients: msg.clients };
-                        ws.__finishOk?.();
-                    }
-                },
-            });
-            return result ?? { clients: [] };
-        },
-        catch: (error) => {
-            const message = formatError(error);
-            return new CliError({
-                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
-                message,
-                exitCode: 1,
-                details: { url, timeout_ms: timeoutMs },
-            });
-        },
-    }),
-});

package/dist/apps/cli/tests/apply.contract.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: apply --dry-run --json', () => {
-    it('prints ok envelope and does not require queue db', async () => {
-        const payload = '[{"type":"create_rem","payload":{"fooBar":1}}]';
-        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', payload]);
-        expect(res.exitCode).toBe(0);
-        expect(res.stderr).toBe('');
-        const parsed = JSON.parse(res.stdout.trim());
-        expect(parsed.ok).toBe(true);
-        expect(parsed.data.dry_run).toBe(true);
-        expect(Array.isArray(parsed.data.ops)).toBe(true);
-        expect(parsed.data.ops[0].type).toBe('create_rem');
-        expect(parsed.data.ops[0].payload.foo_bar).toBe(1);
-    });
-    it('accepts object payload with meta (and normalizes keys)', async () => {
-        const payload = JSON.stringify({
-            ops: [{ type: 'create_rem', payload: { fooBar: 1 } }],
-            meta: { traceId: 't1', fooBar: 2 },
-            clientId: 'test-client',
-        });
-        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', payload]);
-        expect(res.exitCode).toBe(0);
-        expect(res.stderr).toBe('');
-        const parsed = JSON.parse(res.stdout.trim());
-        expect(parsed.ok).toBe(true);
-        expect(parsed.data.dry_run).toBe(true);
-        expect(parsed.data.meta.trace_id).toBe('t1');
-        expect(parsed.data.meta.foo_bar).toBe(2);
-    });
-});

package/dist/apps/cli/tests/db-recent.contract.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import os from 'node:os';
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: db recent --json', () => {
-    it('prints a single json envelope and keeps stderr empty on db error', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
-        const missingDb = path.join(tmpDir, 'missing-remnote.db');
-        try {
-            const res = await runCli(['--json', '--remnote-db', missingDb, 'db', 'recent']);
-            expect(res.exitCode).toBe(1);
-            expect(res.stderr).toBe('');
-            const parsed = JSON.parse(res.stdout.trim());
-            expect(parsed.ok).toBe(false);
-            expect(parsed.error.code).toBe('DB_UNAVAILABLE');
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/apps/cli/tests/help.contract.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runCli } from './helpers/runCli.js';
-function stripAnsi(input) {
-    return input.replace(/\u001b\[[0-9;]*m/g, '');
-}
-describe('cli contract: --help', () => {
-    it('prints root help with subcommands', async () => {
-        const res = await runCli(['--help']);
-        expect(res.exitCode).toBe(0);
-        expect(res.stderr).toBe('');
-        const out = stripAnsi(res.stdout);
-        expect(out).toContain('remnote');
-        expect(out).toContain('ws');
-        expect(out).toContain('queue');
-        expect(out).toContain('apply');
-        expect(out).toContain('read');
-        expect(out).toContain('write');
-        expect(out).toContain('wechat');
-    });
-    it('prints ws help with subcommands', async () => {
-        const res = await runCli(['ws', '--help']);
-        expect(res.exitCode).toBe(0);
-        expect(res.stderr).toBe('');
-        const out = stripAnsi(res.stdout);
-        expect(out).toContain('health');
-        expect(out).toContain('start');
-        expect(out).toContain('stop');
-        expect(out).toContain('status');
-    });
-});

package/dist/apps/cli/tests/helpers/runCli.js

@@ -1,45 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-export async function runCli(args, options) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const repoRoot = path.resolve(__dirname, '../../../../');
-    const entry = path.join(repoRoot, 'apps/cli/src/main.ts');
-    const timeoutMs = options?.timeoutMs ?? 30_000;
-    return await new Promise((resolve) => {
-        const child = spawn('bun', ['x', 'tsx', entry, ...args], {
-            cwd: repoRoot,
-            env: { ...process.env, ...(options?.env ?? {}) },
-            stdio: 'pipe',
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        child.stdout.on('data', (d) => {
-            stdout += d;
-        });
-        child.stderr.on('data', (d) => {
-            stderr += d;
-        });
-        if (options?.stdin !== undefined) {
-            child.stdin.setDefaultEncoding('utf8');
-            child.stdin.write(options.stdin);
-            child.stdin.end();
-        }
-        else {
-            child.stdin.end();
-        }
-        const timer = setTimeout(() => {
-            try {
-                child.kill('SIGKILL');
-            }
-            catch (_) { }
-        }, timeoutMs);
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ exitCode: typeof code === 'number' ? code : 1, stdout, stderr });
-        });
-    });
-}

package/dist/apps/cli/tests/ids-output.contract.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import os from 'node:os';
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: --ids output', () => {
-    it('prints ids one per line', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
-        const tmpHome = path.join(tmpDir, 'home');
-        const queueDb = path.join(tmpDir, 'queue.sqlite');
-        try {
-            const payload = '[{"type":"create_rem","payload":{"text":"hello"}}]';
-            const res = await runCli(['--ids', 'apply', '--payload', payload], {
-                env: { HOME: tmpHome, REMNOTE_QUEUE_DB: queueDb },
-            });
-            expect(res.exitCode).toBe(0);
-            expect(res.stderr).toBe('');
-            const lines = res.stdout
-                .split(/\r?\n/)
-                .map((l) => l.trim())
-                .filter(Boolean);
-            expect(lines.length).toBe(2);
-            expect(lines[0].length).toBeGreaterThan(10);
-            expect(lines[1].length).toBeGreaterThan(10);
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/apps/cli/tests/payload-stdin.contract.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: --payload - stdin', () => {
-    it('reads payload from stdin in dry-run mode', async () => {
-        const stdin = '[{"type":"create_rem","payload":{"fooBar":1}}]';
-        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', '-'], { stdin });
-        expect(res.exitCode).toBe(0);
-        expect(res.stderr).toBe('');
-        const parsed = JSON.parse(res.stdout.trim());
-        expect(parsed.ok).toBe(true);
-        expect(parsed.data.dry_run).toBe(true);
-        expect(parsed.data.ops[0].type).toBe('create_rem');
-        expect(parsed.data.ops[0].payload.foo_bar).toBe(1);
-    });
-});

package/dist/apps/cli/tests/read-search.contract.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import os from 'node:os';
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: read search --json', () => {
-    it('prints a single json envelope and keeps stderr empty on db error', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
-        const missingDb = path.join(tmpDir, 'missing-remnote.db');
-        try {
-            const res = await runCli(['--json', '--remnote-db', missingDb, 'read', 'search', '--query', 'hello']);
-            expect(res.exitCode).toBe(1);
-            expect(res.stderr).toBe('');
-            const parsed = JSON.parse(res.stdout.trim());
-            expect(parsed.ok).toBe(false);
-            expect(parsed.error.code).toBe('DB_UNAVAILABLE');
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/apps/cli/tests/ws-health.contract.test.js

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import os from 'node:os';
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { startWebSocketBridge } from '../../../packages/mcp/src/ws/bridge.js';
-import { runCli } from './helpers/runCli.js';
-describe('cli contract: ws health --json', () => {
-    it('prints ok envelope and health data', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
-        const queueDb = path.join(tmpDir, 'queue.sqlite');
-        const prevQueueDb = process.env.REMNOTE_QUEUE_DB;
-        process.env.REMNOTE_QUEUE_DB = queueDb;
-        const started = startWebSocketBridge({ enable: true, port: 0, path: '/ws' });
-        expect(started).toBeTruthy();
-        try {
-            const addr = started.wss.address();
-            const port = typeof addr === 'string' ? Number(addr) : addr.port;
-            const wsUrl = `ws://localhost:${port}/ws`;
-            const res = await runCli(['--json', '--ws-url', wsUrl, 'ws', 'health']);
-            expect(res.exitCode).toBe(0);
-            expect(res.stderr).toBe('');
-            const parsed = JSON.parse(res.stdout.trim());
-            expect(parsed.ok).toBe(true);
-            expect(parsed.data.url).toBe(wsUrl);
-            expect(typeof parsed.data.rtt_ms).toBe('number');
-        }
-        finally {
-            await started.close();
-            if (prevQueueDb === undefined)
-                delete process.env.REMNOTE_QUEUE_DB;
-            else
-                process.env.REMNOTE_QUEUE_DB = prevQueueDb;
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/apps/cli/vitest.config.js

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        environment: 'node',
-        include: ['tests/**/*.test.ts'],
-    },
-});

package/dist/packages/mcp/src/public.js

@@ -1,18 +0,0 @@
-export { startWebSocketBridge } from './ws/bridge.js';
-export { openQueueDb } from './queue/db.js';
-export { enqueueTxn, getTxnIdByOpId, queueStats } from './queue/dao.js';
-export { discoverBackups, formatDateWithPattern, getDateFormatting, withResolvedDatabase } from './tools/shared.js';
-export { TYPES } from './tools/listSupportedOps.js';
-export { executeListRemBackups } from './tools/listRemBackups.js';
-export { executeSummarizeTopicActivity } from './tools/summarizeTopicActivity.js';
-export { executeListRemReferences } from './tools/listRemReferences.js';
-export { executeSummarizeDailyNotes } from './tools/summarizeDailyNotes.js';
-export { executeSearchRemOverview } from './tools/searchRemOverview.js';
-export { executeInspectRemDoc } from './tools/inspectRemDoc.js';
-export { executeOutlineRemSubtree } from './tools/outlineRemSubtree.js';
-export { executeReadRemTable } from './tools/readRemTable.js';
-export { executeFindRemsByReference } from './tools/findRemsByReference.js';
-export { executeGetRemConnections } from './tools/getRemConnections.js';
-export { executeListTodos } from './tools/listTodos.js';
-export { executeResolveRemReference } from './tools/resolveRemReference.js';
-export { executeSearchQuery } from './tools/executeSearchQuery.js';