@genspark/opencode-conversation-archiver 0.1.0

package/dist/push-worker.d.ts

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

package/dist/push-worker.js

@@ -0,0 +1,12 @@
+import { defaultPaths, push } from './core.js';
+const repo = process.argv[2];
+const app = process.argv[3];
+if (repo) {
+    const paths = defaultPaths();
+    if (app) {
+        paths.app = app;
+        paths.pushLog = `${app}/push.log`;
+        paths.log = `${app}/archive.log`;
+    }
+    await push(repo, paths);
+}

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const server: Plugin;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,160 @@
+import { tool } from '@opencode-ai/plugin';
+import { archiveConversation, commitPending, defaultPaths, doctor, emitNotification, status, upload, } from './core.js';
+function optionPaths(options) {
+    const paths = defaultPaths();
+    const appDir = typeof options?.appDir === 'string' ? options.appDir : undefined;
+    if (!appDir)
+        return paths;
+    return {
+        app: appDir,
+        config: `${appDir}/config.json`,
+        state: `${appDir}/state`,
+        index: `${appDir}/state/_index.json`,
+        log: `${appDir}/archive.log`,
+        pushLog: `${appDir}/push.log`,
+        credentials: `${appDir}/git-credentials`,
+    };
+}
+async function fetchConversation(input, sessionID) {
+    const [sessionResult, messagesResult] = await Promise.all([
+        input.client.session.get({ path: { id: sessionID }, throwOnError: true }),
+        input.client.session.messages({
+            path: { id: sessionID },
+            throwOnError: true,
+        }),
+    ]);
+    if (!sessionResult.data || !messagesResult.data)
+        throw new Error(`OpenCode returned no data for session ${sessionID}`);
+    return { session: sessionResult.data, messages: messagesResult.data };
+}
+async function report(input, sessionID, error) {
+    await input.client.app
+        .log({
+        body: {
+            service: 'opencode-conversation-archiver',
+            level: 'error',
+            message: 'Failed to archive conversation',
+            extra: {
+                sessionID,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        },
+    })
+        .catch(() => undefined);
+}
+export const server = async (input, rawOptions) => {
+    const options = rawOptions;
+    const paths = optionPaths(options);
+    const pending = new Map();
+    const enqueue = (sessionID, notify) => {
+        const previous = pending.get(sessionID) ?? Promise.resolve();
+        const run = previous
+            .catch(() => undefined)
+            .then(async () => {
+            try {
+                const conversation = await fetchConversation(input, sessionID);
+                if (conversation.session.projectID !== input.project.id ||
+                    conversation.session.parentID) {
+                    return;
+                }
+                const result = await archiveConversation(conversation, paths);
+                if (notify && result.file)
+                    await emitNotification(sessionID, conversation.session.title, result.turns);
+            }
+            catch (error) {
+                await report(input, sessionID, error);
+            }
+        })
+            .finally(() => {
+            if (pending.get(sessionID) === run)
+                pending.delete(sessionID);
+        });
+        pending.set(sessionID, run);
+    };
+    return {
+        event: async ({ event }) => {
+            if (event.type === 'session.status' &&
+                event.properties.status.type === 'idle') {
+                enqueue(event.properties.sessionID, true);
+            }
+        },
+        dispose: async () => {
+            await Promise.allSettled(pending.values());
+        },
+        tool: {
+            conversation_archive_status: tool({
+                description: 'Show the OpenCode conversation archive mode, repository, remote, commits, and pending changes.',
+                args: {},
+                execute: async () => status(paths),
+            }),
+            conversation_archive_doctor: tool({
+                description: 'Run a read-only diagnosis of the OpenCode conversation archiver, including git remote authentication.',
+                args: {},
+                execute: async () => doctor(paths),
+            }),
+            conversation_archive_current: tool({
+                description: 'Immediately archive the current OpenCode conversation. Normally automatic at the end of every turn.',
+                args: {},
+                execute: async (_args, context) => {
+                    await context.ask({
+                        permission: 'conversation-archive-write',
+                        patterns: ['current session'],
+                        always: [],
+                        metadata: {},
+                    });
+                    const conversation = await fetchConversation(input, context.sessionID);
+                    if (conversation.session.projectID !== input.project.id ||
+                        conversation.session.parentID)
+                        return 'Skipped session outside the current top-level project.';
+                    const result = await archiveConversation(conversation, paths);
+                    return result.file
+                        ? `Archived ${result.turns} turn(s) to ${result.file}`
+                        : 'No visible conversation content to archive.';
+                },
+            }),
+            conversation_archive_backfill: tool({
+                description: 'Archive all existing top-level OpenCode sessions visible in the current project, then commit and push once.',
+                args: {},
+                execute: async (_args, context) => {
+                    await context.ask({
+                        permission: 'conversation-archive-backfill',
+                        patterns: ['all sessions in current OpenCode project'],
+                        always: [],
+                        metadata: {},
+                    });
+                    const listed = await input.client.session.list({ throwOnError: true });
+                    const sessions = (listed.data || []);
+                    let archived = 0;
+                    let skipped = 0;
+                    for (const session of sessions) {
+                        // OpenCode's list endpoint can include unrelated projects; the tool
+                        // promises a current-project backfill and must not cross that boundary.
+                        if (session.projectID !== input.project.id || session.parentID) {
+                            skipped += 1;
+                            continue;
+                        }
+                        try {
+                            const result = await archiveConversation(await fetchConversation(input, session.id), paths, false);
+                            if (result.file)
+                                archived += 1;
+                            else
+                                skipped += 1;
+                        }
+                        catch {
+                            skipped += 1;
+                        }
+                    }
+                    const commit = await commitPending(paths, `backfill ${archived} session(s): ${new Date().toLocaleString()}`);
+                    if (commit.error)
+                        return `Backfilled ${archived} session(s), skipped ${skipped}. Commit failed: ${commit.error}`;
+                    const pushed = await upload(paths);
+                    return `Backfilled ${archived} session(s), skipped ${skipped}. ${pushed}`;
+                },
+            }),
+        },
+    };
+};
+export default {
+    id: 'genspark.opencode-conversation-archiver',
+    server,
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@genspark/opencode-conversation-archiver",
+  "version": "0.1.0",
+  "description": "Archive OpenCode conversations as readable Markdown in a git repository",
+  "keywords": [
+    "opencode",
+    "conversation",
+    "archive",
+    "git",
+    "genspark"
+  ],
+  "author": "Genspark",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wework5119/gen-spark.git",
+    "directory": "toolkits/opencode-conversation-archiver"
+  },
+  "homepage": "https://github.com/wework5119/gen-spark/tree/main/toolkits/opencode-conversation-archiver#readme",
+  "bugs": {
+    "url": "https://github.com/wework5119/gen-spark/issues"
+  },
+  "type": "module",
+  "main": "./dist/server.js",
+  "exports": {
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "config": {
+        "mode": "auto"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "opencode-conversation-archiver": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "pack:dry-run": "npm pack --dry-run",
+    "prepublishOnly": "npm run lint && npm test && npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "opencode": ">=1.17.18 <2"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.17.18"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.17.18",
+    "@opencode-ai/sdk": "1.17.18",
+    "@types/bun": "latest",
+    "typescript": "^5.8.2",
+    "vitest": "^4.0.0"
+  }
+}