agent-remnote 0.0.1 → 0.1.0

package/dist/apps/cli/src/commands/read/index.js

@@ -0,0 +1,21 @@
+import { Command } from '@effect/cli';
+import { readByReferenceCommand } from './by-reference.js';
+import { readConnectionsCommand } from './connections.js';
+import { readInspectCommand } from './inspect.js';
+import { readOutlineCommand } from './outline.js';
+import { readQueryCommand } from './query.js';
+import { readReferencesCommand } from './references.js';
+import { readResolveRefCommand } from './resolve-ref.js';
+import { readSearchCommand } from './search.js';
+import { readTableCommand } from './table.js';
+export const readCommand = Command.make('read', {}).pipe(Command.withSubcommands([
+    readSearchCommand,
+    readQueryCommand,
+    readOutlineCommand,
+    readInspectCommand,
+    readResolveRefCommand,
+    readConnectionsCommand,
+    readReferencesCommand,
+    readByReferenceCommand,
+    readTableCommand,
+]));

package/dist/apps/cli/src/commands/read/inspect.js

@@ -0,0 +1,34 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeInspectRemDoc } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const maxReferenceDepth = Options.integer('max-reference-depth').pipe(Options.optional, Options.map(optionToUndefined));
+export const readInspectCommand = Command.make('inspect', {
+    id: Options.text('id'),
+    expandReferences: Options.boolean('expand-references'),
+    maxReferenceDepth,
+}, ({ id, expandReferences, maxReferenceDepth }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const result = yield* Effect.tryPromise({
+        try: async () => await executeInspectRemDoc({
+            id,
+            dbPath: cfg.remnoteDb,
+            expandReferences,
+            maxReferenceDepth: maxReferenceDepth,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    const summaryText = result?.summary?.text ? String(result.summary.text) : '';
+    const refs = Array.isArray(result?.summary?.references) ? result.summary.references.length : 0;
+    const md = [`- id: ${String(result.id ?? id)}`, summaryText ? `- text: ${summaryText}` : '', `- references: ${refs}`]
+        .filter(Boolean)
+        .join('\n');
+    yield* writeSuccess({ data: result, md });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/outline.js

@@ -0,0 +1,59 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeOutlineRemSubtree } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { RefResolver } from '../../services/RefResolver.js';
+import { CliError } from '../../services/Errors.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const depth = Options.integer('depth').pipe(Options.optional, Options.map(optionToUndefined));
+const offset = Options.integer('offset').pipe(Options.optional, Options.map(optionToUndefined));
+const nodes = Options.integer('nodes').pipe(Options.optional, Options.map(optionToUndefined));
+const format = Options.choice('format', ['md', 'json']).pipe(Options.optional, Options.map(optionToUndefined));
+const id = Options.text('id').pipe(Options.optional, Options.map(optionToUndefined));
+const ref = Options.text('ref').pipe(Options.optional, Options.map(optionToUndefined));
+export const readOutlineCommand = Command.make('outline', {
+    id,
+    ref,
+    depth,
+    offset,
+    nodes,
+    format,
+    excludeProperties: Options.boolean('exclude-properties'),
+    includeEmpty: Options.boolean('include-empty'),
+    expandReferences: Options.boolean('expand-references'),
+    maxReferenceDepth: Options.integer('max-reference-depth').pipe(Options.optional, Options.map(optionToUndefined)),
+    detail: Options.boolean('detail'),
+}, ({ id, ref, depth, offset, nodes, format, excludeProperties, includeEmpty, expandReferences, maxReferenceDepth, detail }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const refs = yield* RefResolver;
+    if (id && ref) {
+        return yield* Effect.fail(new CliError({ code: 'INVALID_ARGS', message: '--id 与 --ref 只能二选一', exitCode: 2 }));
+    }
+    const resolvedId = ref ? yield* refs.resolve(ref) : id;
+    if (!resolvedId) {
+        return yield* Effect.fail(new CliError({ code: 'INVALID_ARGS', message: '必须提供 --id 或 --ref', exitCode: 2 }));
+    }
+    const result = yield* Effect.tryPromise({
+        try: async () => await executeOutlineRemSubtree({
+            id: resolvedId,
+            dbPath: cfg.remnoteDb,
+            maxDepth: depth,
+            startOffset: offset,
+            maxNodes: nodes,
+            format: format === 'json' ? 'json' : 'markdown',
+            excludeProperties,
+            includeEmpty,
+            expandReferences: expandReferences === false ? false : undefined,
+            maxReferenceDepth: maxReferenceDepth,
+            detail,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: result, md: result.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/query.js

@@ -0,0 +1,95 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeSearchQuery } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { CliError } from '../../services/Errors.js';
+import { Payload } from '../../services/Payload.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+function buildMarkdown(items, total) {
+    const lines = [`# Query 结果（${items.length}/${total}）`];
+    for (const item of items) {
+        const title = (item?.title && String(item.title).trim()) || '';
+        const head = title ? `${title} (${item.id})` : String(item.id);
+        lines.push(`- ${head}`);
+        if (item?.snippet)
+            lines.push(`  - ${String(item.snippet)}`);
+    }
+    return lines.join('\n');
+}
+const payload = Options.text('payload').pipe(Options.optional, Options.map(optionToUndefined));
+const text = Options.text('text').pipe(Options.optional, Options.map(optionToUndefined));
+const tag = Options.text('tag').pipe(Options.repeated);
+const limit = Options.integer('limit').pipe(Options.optional, Options.map(optionToUndefined));
+const offset = Options.integer('offset').pipe(Options.optional, Options.map(optionToUndefined));
+const snippetLength = Options.integer('snippet-length').pipe(Options.optional, Options.map(optionToUndefined));
+const sort = Options.choice('sort', ['rank', 'updatedAt', 'createdAt']).pipe(Options.optional, Options.map(optionToUndefined));
+const sortDirection = Options.choice('sort-direction', ['asc', 'desc']).pipe(Options.optional, Options.map(optionToUndefined));
+export const readQueryCommand = Command.make('query', { payload, text, tag, limit, offset, snippetLength, sort, sortDirection }, ({ payload, text, tag, limit, offset, snippetLength, sort, sortDirection }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const payloadSvc = yield* Payload;
+    const queryObj = {};
+    if (payload) {
+        const raw = yield* payloadSvc.readJson(payload);
+        if (raw && typeof raw === 'object' && raw.query && raw.query.root) {
+            Object.assign(queryObj, raw);
+        }
+        else if (raw && typeof raw === 'object' && raw.root) {
+            Object.assign(queryObj, { query: raw });
+        }
+        else {
+            return yield* Effect.fail(new CliError({
+                code: 'INVALID_PAYLOAD',
+                message: 'payload 形状不合法：需要 { query: { root: ... } } 或 { root: ... }',
+                exitCode: 2,
+            }));
+        }
+    }
+    else {
+        const nodes = [];
+        if (text && text.trim()) {
+            nodes.push({ type: 'text', value: text.trim(), mode: 'contains' });
+        }
+        for (const t of tag ?? []) {
+            const v = t.trim();
+            if (v)
+                nodes.push({ type: 'tag', id: v });
+        }
+        if (nodes.length === 0) {
+            return yield* Effect.fail(new CliError({
+                code: 'INVALID_ARGS',
+                message: '请提供 --payload 或至少一个筛选条件（例如 --text / --tag）',
+                exitCode: 2,
+            }));
+        }
+        queryObj.query = {
+            root: nodes.length === 1 ? nodes[0] : { type: 'and', nodes },
+            sort: sort === 'rank'
+                ? { mode: 'rank' }
+                : sort === 'updatedAt'
+                    ? { mode: 'updatedAt', direction: sortDirection ?? 'desc' }
+                    : sort === 'createdAt'
+                        ? { mode: 'createdAt', direction: sortDirection ?? 'desc' }
+                        : undefined,
+        };
+    }
+    const { payload: result } = yield* Effect.tryPromise({
+        try: async () => await executeSearchQuery({
+            ...queryObj,
+            dbPath: cfg.remnoteDb,
+            limit: limit,
+            offset: offset,
+            snippetLength: snippetLength,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({
+        data: result,
+        md: buildMarkdown(result.items ?? [], Number(result.totalMatched ?? 0)),
+    });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/references.js

@@ -0,0 +1,41 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeListRemReferences } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const maxDepth = Options.integer('max-depth').pipe(Options.optional, Options.map(optionToUndefined));
+const inboundMaxDepth = Options.integer('inbound-max-depth').pipe(Options.optional, Options.map(optionToUndefined));
+export const readReferencesCommand = Command.make('references', {
+    id: Options.text('id'),
+    includeDescendants: Options.boolean('include-descendants'),
+    maxDepth,
+    includeOccurrences: Options.boolean('include-occurrences'),
+    resolveText: Options.boolean('resolve-text'),
+    includeInbound: Options.boolean('include-inbound'),
+    inboundMaxDepth,
+}, ({ id, includeDescendants, maxDepth, includeOccurrences, resolveText, includeInbound, inboundMaxDepth }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const payload = yield* Effect.tryPromise({
+        try: async () => {
+            const { payload } = await executeListRemReferences({
+                id,
+                dbPath: cfg.remnoteDb,
+                includeDescendants,
+                maxDepth: maxDepth,
+                includeOccurrences,
+                resolveText: resolveText === false ? false : undefined,
+                includeInbound,
+                inboundMaxDepth: inboundMaxDepth,
+            });
+            return payload;
+        },
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: payload, md: payload.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/resolve-ref.js

@@ -0,0 +1,32 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeResolveRemReference } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+const ids = Options.text('ids').pipe(Options.repeated);
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const maxReferenceDepth = Options.integer('max-reference-depth').pipe(Options.optional, Options.map(optionToUndefined));
+export const readResolveRefCommand = Command.make('resolve-ref', {
+    ids,
+    expandReferences: Options.boolean('expand-references'),
+    maxReferenceDepth,
+    detail: Options.boolean('detail'),
+}, ({ ids, expandReferences, maxReferenceDepth, detail }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const result = yield* Effect.tryPromise({
+        try: async () => await executeResolveRemReference({
+            ids,
+            dbPath: cfg.remnoteDb,
+            expandReferences: expandReferences === false ? false : undefined,
+            maxReferenceDepth: maxReferenceDepth,
+            detail,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: result, md: result.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/search.js

@@ -0,0 +1,40 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeSearchRemOverview } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const timeRange = Options.text('time').pipe(Options.optional, Options.map(optionToUndefined));
+const parentId = Options.text('parent').pipe(Options.optional, Options.map(optionToUndefined));
+const limit = Options.integer('limit').pipe(Options.optional, Options.map(optionToUndefined));
+const offset = Options.integer('offset').pipe(Options.optional, Options.map(optionToUndefined));
+export const readSearchCommand = Command.make('search', {
+    query: Options.text('query'),
+    timeRange,
+    parentId,
+    pagesOnly: Options.boolean('pages-only'),
+    excludePages: Options.boolean('exclude-pages'),
+    limit,
+    offset,
+}, ({ query, timeRange, parentId, pagesOnly, excludePages, limit, offset }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const result = yield* Effect.tryPromise({
+        try: async () => await executeSearchRemOverview({
+            query,
+            dbPath: cfg.remnoteDb,
+            timeRange: timeRange,
+            parentId,
+            pagesOnly,
+            excludePages,
+            limit: limit,
+            offset: offset,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: result, md: result.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/read/table.js

@@ -0,0 +1,32 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeReadRemTable } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown, unwrapStructuredContent } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const limit = Options.integer('limit').pipe(Options.optional, Options.map(optionToUndefined));
+const offset = Options.integer('offset').pipe(Options.optional, Options.map(optionToUndefined));
+export const readTableCommand = Command.make('table', {
+    id: Options.text('id'),
+    includeOptions: Options.boolean('include-options'),
+    limit,
+    offset,
+}, ({ id, includeOptions, limit, offset }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const payload = yield* Effect.tryPromise({
+        try: async () => unwrapStructuredContent(await executeReadRemTable({
+            tagId: id,
+            dbPath: cfg.remnoteDb,
+            includeOptions,
+            limit: limit,
+            offset: offset,
+        })),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: payload, md: payload.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/todos/index.js

@@ -0,0 +1,3 @@
+import { Command } from '@effect/cli';
+import { todosListCommand } from './list.js';
+export const todosCommand = Command.make('todos', {}).pipe(Command.withSubcommands([todosListCommand]));

package/dist/apps/cli/src/commands/todos/list.js

@@ -0,0 +1,33 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeListTodos } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown, unwrapStructuredContent } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const status = Options.choice('status', ['unfinished', 'finished', 'all']).pipe(Options.optional, Options.map(optionToUndefined));
+const ancestor = Options.text('ancestor').pipe(Options.optional, Options.map(optionToUndefined));
+const dueBefore = Options.text('due-before').pipe(Options.optional, Options.map(optionToUndefined));
+const dueAfter = Options.text('due-after').pipe(Options.optional, Options.map(optionToUndefined));
+const limit = Options.integer('limit').pipe(Options.optional, Options.map(optionToUndefined));
+const offset = Options.integer('offset').pipe(Options.optional, Options.map(optionToUndefined));
+export const todosListCommand = Command.make('list', { status, ancestor, dueBefore, dueAfter, limit, offset }, ({ status, ancestor, dueBefore, dueAfter, limit, offset }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const payload = yield* Effect.tryPromise({
+        try: async () => unwrapStructuredContent(await executeListTodos({
+            dbPath: cfg.remnoteDb,
+            status: status,
+            ancestorId: ancestor,
+            dueBefore: dueBefore,
+            dueAfter: dueAfter,
+            limit: limit,
+            offset: offset,
+        })),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: payload, md: payload.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/topic/index.js

@@ -0,0 +1,3 @@
+import { Command } from '@effect/cli';
+import { topicSummaryCommand } from './summary.js';
+export const topicCommand = Command.make('topic', {}).pipe(Command.withSubcommands([topicSummaryCommand]));

package/dist/apps/cli/src/commands/topic/summary.js

@@ -0,0 +1,44 @@
+import { Command } from '@effect/cli';
+import * as Options from '@effect/cli/Options';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { executeSummarizeTopicActivity } from '../../adapters/mcp.js';
+import { AppConfig } from '../../services/AppConfig.js';
+import { CliError } from '../../services/Errors.js';
+import { writeFailure, writeSuccess } from '../_shared.js';
+import { cliErrorFromUnknown } from '../_tool.js';
+function optionToUndefined(opt) {
+    return Option.isSome(opt) ? opt.value : undefined;
+}
+const keywords = Options.text('keywords').pipe(Options.optional, Options.map(optionToUndefined));
+const query = Options.text('query').pipe(Options.optional, Options.map(optionToUndefined));
+const timeRange = Options.text('time').pipe(Options.optional, Options.map(optionToUndefined));
+const maxResults = Options.integer('max-results').pipe(Options.optional, Options.map(optionToUndefined));
+const maxNodesPerResult = Options.integer('max-nodes').pipe(Options.optional, Options.map(optionToUndefined));
+const groupBy = Options.choice('group-by', ['none', 'parent', 'date']).pipe(Options.optional, Options.map(optionToUndefined));
+export const topicSummaryCommand = Command.make('summary', { keywords, query, timeRange, maxResults, maxNodesPerResult, groupBy }, ({ keywords, query, timeRange, maxResults, maxNodesPerResult, groupBy }) => Effect.gen(function* () {
+    const cfg = yield* AppConfig;
+    const keywordList = keywords
+        ? keywords
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : undefined;
+    const queryText = query?.trim() || undefined;
+    if ((!keywordList || keywordList.length === 0) && !queryText) {
+        return yield* Effect.fail(new CliError({ code: 'INVALID_ARGS', message: '请提供 --keywords 或 --query', exitCode: 2 }));
+    }
+    const result = yield* Effect.tryPromise({
+        try: async () => await executeSummarizeTopicActivity({
+            keywords: keywordList,
+            query: queryText,
+            timeRange: timeRange,
+            maxResults: maxResults,
+            maxNodesPerResult: maxNodesPerResult,
+            groupBy: groupBy,
+            dbPath: cfg.remnoteDb,
+        }),
+        catch: (e) => cliErrorFromUnknown(e, { code: 'DB_UNAVAILABLE' }),
+    });
+    yield* writeSuccess({ data: result, md: result.markdown ?? '' });
+}).pipe(Effect.catchAll(writeFailure)));

package/dist/apps/cli/src/commands/wechat/index.js

@@ -0,0 +1,3 @@
+import { Command } from '@effect/cli';
+import { wechatOutlineCommand } from './outline.js';
+export const wechatCommand = Command.make('wechat', {}).pipe(Command.withSubcommands([wechatOutlineCommand]));