opencode-lcm 0.11.0

package/dist/index.js

@@ -0,0 +1,306 @@
+import { tool } from '@opencode-ai/plugin';
+import { resolveOptions } from './options.js';
+import { SqliteLcmStore } from './store.js';
+export const OpencodeLcmPlugin = async (ctx, rawOptions) => {
+    const options = resolveOptions(rawOptions);
+    const store = new SqliteLcmStore(ctx.directory, options);
+    await store.init();
+    return {
+        event: async ({ event }) => {
+            await store.captureDeferred(event);
+        },
+        tool: {
+            lcm_status: tool({
+                description: 'Show archived LCM capture stats',
+                args: {},
+                async execute() {
+                    const stats = await store.stats();
+                    const lines = [
+                        `schema_version=${stats.schemaVersion}`,
+                        `total_events=${stats.totalEvents}`,
+                        `session_count=${stats.sessionCount}`,
+                        `root_sessions=${stats.rootSessionCount}`,
+                        `branched_sessions=${stats.branchedSessionCount}`,
+                        `pinned_sessions=${stats.pinnedSessionCount}`,
+                        `worktrees=${stats.worktreeCount}`,
+                        `latest_event_at=${stats.latestEventAt ?? 'n/a'}`,
+                        `summary_nodes=${stats.summaryNodeCount}`,
+                        `summary_states=${stats.summaryStateCount}`,
+                        `artifacts=${stats.artifactCount}`,
+                        `artifact_blobs=${stats.artifactBlobCount}`,
+                        `shared_artifact_blobs=${stats.sharedArtifactBlobCount}`,
+                        `orphan_artifact_blobs=${stats.orphanArtifactBlobCount}`,
+                        `default_grep_scope=${options.scopeDefaults.grep}`,
+                        `default_describe_scope=${options.scopeDefaults.describe}`,
+                        `scope_profiles=${options.scopeProfiles.length}`,
+                        `retention_stale_session_days=${options.retention.staleSessionDays ?? 'disabled'}`,
+                        `retention_deleted_session_days=${options.retention.deletedSessionDays ?? 'disabled'}`,
+                        `retention_orphan_blob_days=${options.retention.orphanBlobDays ?? 'disabled'}`,
+                        `automatic_retrieval_enabled=${options.automaticRetrieval.enabled}`,
+                        `automatic_retrieval_max_chars=${options.automaticRetrieval.maxChars}`,
+                        `automatic_retrieval_min_tokens=${options.automaticRetrieval.minTokens}`,
+                        `automatic_retrieval_message_hits=${options.automaticRetrieval.maxMessageHits}`,
+                        `automatic_retrieval_summary_hits=${options.automaticRetrieval.maxSummaryHits}`,
+                        `automatic_retrieval_artifact_hits=${options.automaticRetrieval.maxArtifactHits}`,
+                        `automatic_retrieval_scope_order=${options.automaticRetrieval.scopeOrder.join(',')}`,
+                        `automatic_retrieval_scope_budgets=session:${options.automaticRetrieval.scopeBudgets.session},root:${options.automaticRetrieval.scopeBudgets.root},worktree:${options.automaticRetrieval.scopeBudgets.worktree},all:${options.automaticRetrieval.scopeBudgets.all}`,
+                        `automatic_retrieval_stop_target_hits=${options.automaticRetrieval.stop.targetHits}`,
+                        `automatic_retrieval_stop_on_first_scope_with_hits=${options.automaticRetrieval.stop.stopOnFirstScopeWithHits}`,
+                        `fresh_tail_messages=${options.freshTailMessages}`,
+                        `min_messages_for_transform=${options.minMessagesForTransform}`,
+                        `large_content_threshold=${options.largeContentThreshold}`,
+                        `binary_preview_providers=${options.binaryPreviewProviders.join(',')}`,
+                        `preview_byte_peek=${options.previewBytePeek}`,
+                        `privacy_exclude_tool_prefixes=${options.privacy.excludeToolPrefixes.join(',')}`,
+                        `privacy_exclude_path_patterns=${options.privacy.excludePathPatterns.length}`,
+                        `privacy_redact_patterns=${options.privacy.redactPatterns.length}`,
+                        ...Object.entries(stats.eventTypes)
+                            .sort((a, b) => b[1] - a[1])
+                            .slice(0, 10)
+                            .map(([type, count]) => `${type}=${count}`),
+                    ];
+                    return lines.join('\n');
+                },
+            }),
+            lcm_resume: tool({
+                description: 'Show the latest archived resume note',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.resume(args.sessionID);
+                },
+            }),
+            lcm_grep: tool({
+                description: 'Search archived LCM capture with scope',
+                args: {
+                    query: tool.schema.string().min(1),
+                    sessionID: tool.schema.string().optional(),
+                    scope: tool.schema.string().optional(),
+                    limit: tool.schema.number().int().min(1).max(20).optional(),
+                },
+                async execute(args) {
+                    const results = await store.grep({
+                        query: args.query,
+                        sessionID: args.sessionID,
+                        scope: args.scope,
+                        limit: args.limit ?? 5,
+                    });
+                    if (results.length === 0)
+                        return 'No archived matches found.';
+                    return results
+                        .map((result) => {
+                        const suffix = result.sessionID ? ` session=${result.sessionID}` : '';
+                        return `[${result.type}]${suffix} ${result.snippet}`;
+                    })
+                        .join('\n\n');
+                },
+            }),
+            lcm_describe: tool({
+                description: 'Summarize archived session capture with scope',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                    scope: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.describe({
+                        sessionID: args.sessionID,
+                        scope: args.scope,
+                    });
+                },
+            }),
+            lcm_lineage: tool({
+                description: 'Show archived branch lineage for a session',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.lineage(args.sessionID);
+                },
+            }),
+            lcm_pin_session: tool({
+                description: 'Pin a session so retention pruning will skip it',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                    reason: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.pinSession({
+                        sessionID: args.sessionID,
+                        reason: args.reason,
+                    });
+                },
+            }),
+            lcm_unpin_session: tool({
+                description: 'Remove a session retention pin',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.unpinSession({
+                        sessionID: args.sessionID,
+                    });
+                },
+            }),
+            lcm_expand: tool({
+                description: 'Expand archived summary nodes into targeted descendants or raw messages',
+                args: {
+                    sessionID: tool.schema.string().optional(),
+                    nodeID: tool.schema.string().optional(),
+                    query: tool.schema.string().optional(),
+                    depth: tool.schema.number().int().min(1).max(4).optional(),
+                    messageLimit: tool.schema.number().int().min(1).max(20).optional(),
+                    includeRaw: tool.schema.boolean().optional(),
+                },
+                async execute(args) {
+                    return await store.expand({
+                        sessionID: args.sessionID,
+                        nodeID: args.nodeID,
+                        query: args.query,
+                        depth: args.depth,
+                        messageLimit: args.messageLimit,
+                        includeRaw: args.includeRaw,
+                    });
+                },
+            }),
+            lcm_artifact: tool({
+                description: 'View externalized archived content by artifact ID',
+                args: {
+                    artifactID: tool.schema.string().min(1),
+                    chars: tool.schema.number().int().min(200).max(20000).optional(),
+                },
+                async execute(args) {
+                    return await store.artifact({
+                        artifactID: args.artifactID,
+                        chars: args.chars,
+                    });
+                },
+            }),
+            lcm_blob_stats: tool({
+                description: 'Show deduplicated artifact blob stats',
+                args: {
+                    limit: tool.schema.number().int().min(1).max(20).optional(),
+                },
+                async execute(args) {
+                    return await store.blobStats({
+                        limit: args.limit,
+                    });
+                },
+            }),
+            lcm_blob_gc: tool({
+                description: 'Preview or delete orphaned artifact blobs',
+                args: {
+                    apply: tool.schema.boolean().optional(),
+                    limit: tool.schema.number().int().min(1).max(50).optional(),
+                },
+                async execute(args) {
+                    return await store.gcBlobs({
+                        apply: args.apply,
+                        limit: args.limit,
+                    });
+                },
+            }),
+            lcm_doctor: tool({
+                description: 'Inspect or repair archive summaries and indexes',
+                args: {
+                    apply: tool.schema.boolean().optional(),
+                    sessionID: tool.schema.string().optional(),
+                    limit: tool.schema.number().int().min(1).max(50).optional(),
+                },
+                async execute(args) {
+                    return await store.doctor({
+                        apply: args.apply,
+                        sessionID: args.sessionID,
+                        limit: args.limit,
+                    });
+                },
+            }),
+            lcm_retention_report: tool({
+                description: 'Preview stale-session and orphan-blob retention candidates',
+                args: {
+                    staleSessionDays: tool.schema.number().min(0).optional(),
+                    deletedSessionDays: tool.schema.number().min(0).optional(),
+                    orphanBlobDays: tool.schema.number().min(0).optional(),
+                    limit: tool.schema.number().int().min(1).max(50).optional(),
+                },
+                async execute(args) {
+                    return await store.retentionReport({
+                        staleSessionDays: args.staleSessionDays,
+                        deletedSessionDays: args.deletedSessionDays,
+                        orphanBlobDays: args.orphanBlobDays,
+                        limit: args.limit,
+                    });
+                },
+            }),
+            lcm_retention_prune: tool({
+                description: 'Preview or apply stale-session and orphan-blob retention pruning',
+                args: {
+                    apply: tool.schema.boolean().optional(),
+                    staleSessionDays: tool.schema.number().min(0).optional(),
+                    deletedSessionDays: tool.schema.number().min(0).optional(),
+                    orphanBlobDays: tool.schema.number().min(0).optional(),
+                    limit: tool.schema.number().int().min(1).max(50).optional(),
+                },
+                async execute(args) {
+                    return await store.retentionPrune({
+                        apply: args.apply,
+                        staleSessionDays: args.staleSessionDays,
+                        deletedSessionDays: args.deletedSessionDays,
+                        orphanBlobDays: args.orphanBlobDays,
+                        limit: args.limit,
+                    });
+                },
+            }),
+            lcm_export_snapshot: tool({
+                description: 'Export a portable long-memory snapshot to a JSON file',
+                args: {
+                    filePath: tool.schema.string().min(1),
+                    sessionID: tool.schema.string().optional(),
+                    scope: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.exportSnapshot({
+                        filePath: args.filePath,
+                        sessionID: args.sessionID,
+                        scope: args.scope,
+                    });
+                },
+            }),
+            lcm_import_snapshot: tool({
+                description: 'Import a portable long-memory snapshot from a JSON file',
+                args: {
+                    filePath: tool.schema.string().min(1),
+                    mode: tool.schema.string().optional(),
+                    worktreeMode: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    return await store.importSnapshot({
+                        filePath: args.filePath,
+                        mode: args.mode === 'merge' ? 'merge' : 'replace',
+                        worktreeMode: args.worktreeMode === 'preserve' || args.worktreeMode === 'current'
+                            ? args.worktreeMode
+                            : 'auto',
+                    });
+                },
+            }),
+        },
+        'experimental.chat.messages.transform': async (_input, output) => {
+            await store.transformMessages(output.messages);
+        },
+        'experimental.chat.system.transform': async (_input, output) => {
+            const hint = store.systemHint();
+            if (!hint)
+                return;
+            output.system.push(hint);
+        },
+        'experimental.session.compacting': async (input, output) => {
+            const note = await store.buildCompactionContext(input.sessionID);
+            if (!note)
+                return;
+            if (output.context.some((entry) => entry.includes('LCM prototype resume note')))
+                return;
+            output.context.push(note);
+        },
+    };
+};
+export default OpencodeLcmPlugin;

package/dist/logging.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightweight structured logging interface for opencode-lcm.
+ * Silent by default so plugin logs do not corrupt the host terminal UI.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+export declare function setLogger(logger: Logger): void;
+export declare function getLogger(): Logger;
+export declare function isStartupLoggingEnabled(): boolean;

package/dist/logging.js

@@ -0,0 +1,28 @@
+/**
+ * Lightweight structured logging interface for opencode-lcm.
+ * Silent by default so plugin logs do not corrupt the host terminal UI.
+ */
+function isTruthyEnvFlag(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+const silentLogger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};
+let currentLogger = silentLogger;
+export function setLogger(logger) {
+    currentLogger = logger;
+}
+export function getLogger() {
+    return currentLogger;
+}
+export function isStartupLoggingEnabled() {
+    if (typeof process !== 'object' || !process?.env)
+        return false;
+    return isTruthyEnvFlag(process.env.OPENCODE_LCM_STARTUP_LOG);
+}

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import type { OpencodeLcmOptions } from './types.js';
+export declare const DEFAULT_OPTIONS: OpencodeLcmOptions;
+export declare function resolveOptions(raw: unknown): OpencodeLcmOptions;

package/dist/options.js

@@ -0,0 +1,217 @@
+const DEFAULT_INTEROP = {
+    contextMode: true,
+    neverOverrideCompactionPrompt: true,
+    ignoreToolPrefixes: ['ctx_'],
+};
+const DEFAULT_SCOPE_DEFAULTS = {
+    grep: 'session',
+    describe: 'session',
+};
+const DEFAULT_RETENTION = {
+    staleSessionDays: undefined,
+    deletedSessionDays: 30,
+    orphanBlobDays: 14,
+};
+const DEFAULT_PRIVACY = {
+    excludeToolPrefixes: [],
+    excludePathPatterns: [],
+    redactPatterns: [],
+};
+const DEFAULT_AUTOMATIC_RETRIEVAL = {
+    enabled: true,
+    maxChars: 900,
+    minTokens: 2,
+    maxMessageHits: 2,
+    maxSummaryHits: 1,
+    maxArtifactHits: 1,
+    scopeOrder: ['session', 'root', 'worktree'],
+    scopeBudgets: {
+        session: 16,
+        root: 12,
+        worktree: 8,
+        all: 6,
+    },
+    stop: {
+        targetHits: 3,
+        stopOnFirstScopeWithHits: false,
+    },
+};
+export const DEFAULT_OPTIONS = {
+    interop: DEFAULT_INTEROP,
+    scopeDefaults: DEFAULT_SCOPE_DEFAULTS,
+    scopeProfiles: [],
+    retention: DEFAULT_RETENTION,
+    privacy: DEFAULT_PRIVACY,
+    automaticRetrieval: DEFAULT_AUTOMATIC_RETRIEVAL,
+    compactContextLimit: 1200,
+    systemHint: true,
+    freshTailMessages: 10,
+    minMessagesForTransform: 16,
+    summaryCharBudget: 1500,
+    partCharBudget: 160,
+    largeContentThreshold: 1200,
+    artifactPreviewChars: 220,
+    artifactViewChars: 4000,
+    binaryPreviewProviders: [
+        'fingerprint',
+        'byte-peek',
+        'image-dimensions',
+        'pdf-metadata',
+        'zip-metadata',
+    ],
+    previewBytePeek: 16,
+};
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function asBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function asNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function asNonNegativeNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function asOptionalNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function asStringArray(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    const next = value.filter((item) => typeof item === 'string' && item.length > 0);
+    return next.length > 0 ? next : fallback;
+}
+function asScopeName(value, fallback) {
+    return value === 'session' || value === 'root' || value === 'worktree' || value === 'all'
+        ? value
+        : fallback;
+}
+function asScopeNameArray(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    const result = [];
+    for (const item of value) {
+        if (item !== 'session' && item !== 'root' && item !== 'worktree' && item !== 'all')
+            continue;
+        if (result.includes(item))
+            continue;
+        result.push(item);
+    }
+    return result.length > 0 ? result : fallback;
+}
+function asScopeDefaults(value, fallback) {
+    const record = asRecord(value);
+    return {
+        grep: asScopeName(record?.grep, fallback.grep),
+        describe: asScopeName(record?.describe, fallback.describe),
+    };
+}
+function asScopeProfiles(value) {
+    if (!Array.isArray(value))
+        return [];
+    const result = [];
+    for (const item of value) {
+        const record = asRecord(item);
+        const worktree = typeof record?.worktree === 'string' && record.worktree.length > 0
+            ? record.worktree
+            : undefined;
+        if (!worktree)
+            continue;
+        result.push({
+            worktree,
+            grep: record?.grep === undefined
+                ? undefined
+                : asScopeName(record.grep, DEFAULT_SCOPE_DEFAULTS.grep),
+            describe: record?.describe === undefined
+                ? undefined
+                : asScopeName(record.describe, DEFAULT_SCOPE_DEFAULTS.describe),
+        });
+    }
+    return result;
+}
+function asRetentionOptions(value, fallback) {
+    const record = asRecord(value);
+    return {
+        staleSessionDays: record?.staleSessionDays === undefined
+            ? fallback.staleSessionDays
+            : asOptionalNumber(record.staleSessionDays),
+        deletedSessionDays: record?.deletedSessionDays === undefined
+            ? fallback.deletedSessionDays
+            : asOptionalNumber(record.deletedSessionDays),
+        orphanBlobDays: record?.orphanBlobDays === undefined
+            ? fallback.orphanBlobDays
+            : asOptionalNumber(record.orphanBlobDays),
+    };
+}
+function asPrivacyOptions(value, fallback) {
+    const record = asRecord(value);
+    return {
+        excludeToolPrefixes: asStringArray(record?.excludeToolPrefixes, fallback.excludeToolPrefixes),
+        excludePathPatterns: asStringArray(record?.excludePathPatterns, fallback.excludePathPatterns),
+        redactPatterns: asStringArray(record?.redactPatterns, fallback.redactPatterns),
+    };
+}
+function asAutomaticRetrievalOptions(value, fallback) {
+    const record = asRecord(value);
+    return {
+        enabled: asBoolean(record?.enabled, fallback.enabled),
+        maxChars: asNumber(record?.maxChars, fallback.maxChars),
+        minTokens: asNumber(record?.minTokens, fallback.minTokens),
+        maxMessageHits: asNumber(record?.maxMessageHits, fallback.maxMessageHits),
+        maxSummaryHits: asNumber(record?.maxSummaryHits, fallback.maxSummaryHits),
+        maxArtifactHits: asNumber(record?.maxArtifactHits, fallback.maxArtifactHits),
+        scopeOrder: asScopeNameArray(record?.scopeOrder, fallback.scopeOrder),
+        scopeBudgets: asAutomaticRetrievalScopeBudgets(record?.scopeBudgets, fallback.scopeBudgets),
+        stop: asAutomaticRetrievalStopOptions(record?.stop, fallback.stop),
+    };
+}
+function asAutomaticRetrievalScopeBudgets(value, fallback) {
+    const record = asRecord(value);
+    return {
+        session: asNonNegativeNumber(record?.session, fallback.session),
+        root: asNonNegativeNumber(record?.root, fallback.root),
+        worktree: asNonNegativeNumber(record?.worktree, fallback.worktree),
+        all: asNonNegativeNumber(record?.all, fallback.all),
+    };
+}
+function asAutomaticRetrievalStopOptions(value, fallback) {
+    const record = asRecord(value);
+    return {
+        targetHits: asNonNegativeNumber(record?.targetHits, fallback.targetHits),
+        stopOnFirstScopeWithHits: asBoolean(record?.stopOnFirstScopeWithHits, fallback.stopOnFirstScopeWithHits),
+    };
+}
+export function resolveOptions(raw) {
+    const options = asRecord(raw);
+    const interop = asRecord(options?.interop);
+    const scopeDefaults = asScopeDefaults(options?.scopeDefaults, DEFAULT_SCOPE_DEFAULTS);
+    return {
+        interop: {
+            contextMode: asBoolean(interop?.contextMode, DEFAULT_INTEROP.contextMode),
+            neverOverrideCompactionPrompt: asBoolean(interop?.neverOverrideCompactionPrompt, DEFAULT_INTEROP.neverOverrideCompactionPrompt),
+            ignoreToolPrefixes: asStringArray(interop?.ignoreToolPrefixes, DEFAULT_INTEROP.ignoreToolPrefixes),
+        },
+        scopeDefaults,
+        scopeProfiles: asScopeProfiles(options?.scopeProfiles),
+        retention: asRetentionOptions(options?.retention, DEFAULT_RETENTION),
+        privacy: asPrivacyOptions(options?.privacy, DEFAULT_PRIVACY),
+        automaticRetrieval: asAutomaticRetrievalOptions(options?.automaticRetrieval, DEFAULT_AUTOMATIC_RETRIEVAL),
+        compactContextLimit: asNumber(options?.compactContextLimit, DEFAULT_OPTIONS.compactContextLimit),
+        systemHint: asBoolean(options?.systemHint, DEFAULT_OPTIONS.systemHint),
+        storeDir: typeof options?.storeDir === 'string' && options.storeDir.length > 0
+            ? options.storeDir
+            : undefined,
+        freshTailMessages: asNumber(options?.freshTailMessages, DEFAULT_OPTIONS.freshTailMessages),
+        minMessagesForTransform: asNumber(options?.minMessagesForTransform, DEFAULT_OPTIONS.minMessagesForTransform),
+        summaryCharBudget: asNumber(options?.summaryCharBudget, DEFAULT_OPTIONS.summaryCharBudget),
+        partCharBudget: asNumber(options?.partCharBudget, DEFAULT_OPTIONS.partCharBudget),
+        largeContentThreshold: asNumber(options?.largeContentThreshold, DEFAULT_OPTIONS.largeContentThreshold),
+        artifactPreviewChars: asNumber(options?.artifactPreviewChars, DEFAULT_OPTIONS.artifactPreviewChars),
+        artifactViewChars: asNumber(options?.artifactViewChars, DEFAULT_OPTIONS.artifactViewChars),
+        binaryPreviewProviders: asStringArray(options?.binaryPreviewProviders, DEFAULT_OPTIONS.binaryPreviewProviders),
+        previewBytePeek: asNumber(options?.previewBytePeek, DEFAULT_OPTIONS.previewBytePeek),
+    };
+}

package/dist/preview-providers.d.ts

@@ -0,0 +1,20 @@
+import type { Part } from '@opencode-ai/sdk';
+type FilePart = Extract<Part, {
+    type: 'file';
+}>;
+type PreviewContext = {
+    workspaceDirectory: string;
+    file: FilePart;
+    category: string;
+    extension?: string;
+    mime?: string;
+    enabledProviders: string[];
+    bytePeek: number;
+};
+type PreviewOutput = {
+    metadata: Record<string, unknown>;
+    lines: string[];
+    summaryBits: string[];
+};
+export declare function runBinaryPreviewProviders(context: PreviewContext): Promise<PreviewOutput>;
+export {};