@doingdev/opencode-claude-manager-plugin 0.1.11 → 0.1.12

package/dist/claude/claude-agent-sdk-adapter.d.ts

@@ -1,7 +1,7 @@
 import { type Options, type Query, type SDKSessionInfo, type SessionMessage, type SettingSource } from '@anthropic-ai/claude-agent-sdk';
 import type { ClaudeCapabilitySnapshot, ClaudeSessionEvent, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
 export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
-export interface ClaudeAgentSdkFacade {
+interface ClaudeAgentSdkFacade {
     query(params: {
         prompt: string;
         options?: Options;
@@ -22,3 +22,4 @@ export declare class ClaudeAgentSdkAdapter {
     probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
     private buildOptions;
 }
+export {};

package/dist/manager/persistent-manager.d.ts

@@ -1,16 +1,18 @@
-import type { ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
+import type { ClaudeSessionEvent, ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
 import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
 import type { FileRunStateStore } from '../state/file-run-state-store.js';
+import type { TranscriptStore } from '../state/transcript-store.js';
 import type { SessionController } from './session-controller.js';
 import type { GitOperations } from './git-operations.js';
 import type { ContextTracker } from './context-tracker.js';
-export type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
+type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
 export declare class PersistentManager {
     private readonly sessionController;
     private readonly gitOps;
     private readonly stateStore;
     private readonly contextTracker;
-    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker);
+    private readonly transcriptStore;
+    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker, transcriptStore: TranscriptStore);
     /**
      * Send a message to the persistent Claude Code session.
      * Creates a new session if none exists.
@@ -48,6 +50,10 @@ export declare class PersistentManager {
      * Compact the current session to free context.
      */
     compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    /**
+     * Read persisted transcript events for a session.
+     */
+    getTranscriptEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
     /**
      * Execute a full task with run tracking.
      * Creates a run record, sends the message, and persists the result.
@@ -62,3 +68,4 @@ export declare class PersistentManager {
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }
+export {};

package/dist/manager/persistent-manager.js

@@ -4,11 +4,13 @@ export class PersistentManager {
     gitOps;
     stateStore;
     contextTracker;
-    constructor(sessionController, gitOps, stateStore, contextTracker) {
+    transcriptStore;
+    constructor(sessionController, gitOps, stateStore, contextTracker, transcriptStore) {
         this.sessionController = sessionController;
         this.gitOps = gitOps;
         this.stateStore = stateStore;
         this.contextTracker = contextTracker;
+        this.transcriptStore = transcriptStore;
     }
     /**
      * Send a message to the persistent Claude Code session.
@@ -16,6 +18,9 @@ export class PersistentManager {
      */
     async sendMessage(cwd, message, options, onEvent) {
         const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        if (result.sessionId && result.events.length > 0) {
+            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
+        }
         return {
             sessionId: result.sessionId,
             finalText: result.finalText,
@@ -58,7 +63,17 @@ export class PersistentManager {
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        return this.sessionController.compactSession(cwd, onEvent);
+        const result = await this.sessionController.compactSession(cwd, onEvent);
+        if (result.sessionId && result.events.length > 0) {
+            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
+        }
+        return result;
+    }
+    /**
+     * Read persisted transcript events for a session.
+     */
+    getTranscriptEvents(cwd, sessionId) {
+        return this.transcriptStore.readEvents(cwd, sessionId);
     }
     /**
      * Execute a full task with run tracking.

package/dist/manager/session-controller.d.ts

@@ -1,5 +1,5 @@
-import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
 import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
 import type { ContextTracker } from './context-tracker.js';
 export declare class SessionController {
     private readonly sdkAdapter;

package/dist/manager/session-controller.js

@@ -1,5 +1,5 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
 export class SessionController {
     sdkAdapter;
@@ -29,7 +29,7 @@ export class SessionController {
             permissionMode: 'acceptEdits',
             includePartialMessages: true,
             model: options?.model,
-            settingSources: options?.settingSources ?? ['project', 'local'],
+            settingSources: options?.settingSources ?? ['user', 'project', 'local'],
         };
         if (this.activeSessionId) {
             // Resume existing session

package/dist/plugin/claude-manager.plugin.d.ts

@@ -1,4 +1,2 @@
 import { type Plugin } from '@opencode-ai/plugin';
-import type { PersistentRunRecord } from '../types/contracts.js';
 export declare const ClaudeManagerPlugin: Plugin;
-export declare function formatRunToolResult(run: PersistentRunRecord): string;

package/dist/plugin/claude-manager.plugin.js

@@ -104,27 +104,74 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    annotateToolRun(context, 'Sending to Claude Code session', {
-                        hasActiveSession: services.manager.getStatus().sessionId !== null,
+                    const cwd = args.cwd ?? context.worktree;
+                    const hasActiveSession = services.manager.getStatus().sessionId !== null;
+                    context.metadata({
+                        title: hasActiveSession
+                            ? 'Claude Code: Resuming session...'
+                            : 'Claude Code: Initializing...',
+                        metadata: { sessionId: services.manager.getStatus().sessionId },
                     });
-                    const result = await services.manager.sendMessage(args.cwd ?? context.worktree, args.message, { model: args.model }, (event) => {
-                        if (event.type === 'assistant' || event.type === 'tool_call') {
+                    let turnsSoFar = 0;
+                    let costSoFar = 0;
+                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model }, (event) => {
+                        if (event.turns !== undefined) {
+                            turnsSoFar = event.turns;
+                        }
+                        if (event.totalCostUsd !== undefined) {
+                            costSoFar = event.totalCostUsd;
+                        }
+                        const costLabel = `$${costSoFar.toFixed(4)}`;
+                        if (event.type === 'tool_call') {
+                            let toolName = 'tool';
+                            try {
+                                toolName = JSON.parse(event.text).name ?? 'tool';
+                            }
+                            catch {
+                                // ignore parse errors
+                            }
+                            context.metadata({
+                                title: `Claude Code: Running ${toolName}... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    preview: event.text.slice(0, 200),
+                                },
+                            });
+                        }
+                        else if (event.type === 'assistant') {
                             context.metadata({
-                                title: 'Claude Code working...',
+                                title: `Claude Code: Thinking... (${turnsSoFar} turns, ${costLabel})`,
                                 metadata: {
+                                    sessionId: event.sessionId,
                                     type: event.type,
                                     preview: event.text.slice(0, 200),
                                 },
                             });
                         }
                     });
+                    const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
+                    const turns = result.turns ?? 0;
+                    const contextWarning = formatContextWarning(result.context);
+                    if (contextWarning) {
+                        context.metadata({
+                            title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
+                            metadata: { sessionId: result.sessionId, contextWarning },
+                        });
+                    }
+                    else {
+                        context.metadata({
+                            title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
+                            metadata: { sessionId: result.sessionId },
+                        });
+                    }
                     return JSON.stringify({
                         sessionId: result.sessionId,
                         finalText: result.finalText,
                         turns: result.turns,
                         totalCostUsd: result.totalCostUsd,
                         context: result.context,
-                        contextWarning: formatContextWarning(result.context),
+                        contextWarning,
                     }, null, 2);
                 },
             }),
@@ -189,6 +236,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const status = services.manager.getStatus();
                     return JSON.stringify({
                         ...status,
+                        transcriptFile: status.sessionId
+                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                            : null,
                         contextWarning: formatContextWarning(status),
                     }, null, 2);
                 },
@@ -210,18 +260,26 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             claude_manager_sessions: tool({
-                description: 'List Claude sessions or inspect a saved transcript.',
+                description: 'List Claude sessions or inspect a saved transcript. ' +
+                    'When sessionId is provided, returns both SDK transcript and local manager events.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
                     annotateToolRun(context, 'Inspecting Claude session history', {});
+                    const cwd = args.cwd ?? context.worktree;
                     if (args.sessionId) {
-                        const transcript = await services.sessions.getTranscript(args.sessionId, args.cwd ?? context.worktree);
-                        return JSON.stringify(transcript, null, 2);
+                        const [sdkTranscript, localEvents] = await Promise.all([
+                            services.sessions.getTranscript(args.sessionId, cwd),
+                            services.manager.getTranscriptEvents(cwd, args.sessionId),
+                        ]);
+                        return JSON.stringify({
+                            sdkTranscript,
+                            localEvents: localEvents.length > 0 ? localEvents : undefined,
+                        }, null, 2);
                     }
-                    const sessions = await services.sessions.listSessions(args.cwd ?? context.worktree);
+                    const sessions = await services.sessions.listSessions(cwd);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
@@ -304,16 +362,3 @@ function formatContextWarning(context) {
         .replace('{turns}', String(totalTurns))
         .replace('{cost}', totalCostUsd.toFixed(2));
 }
-export function formatRunToolResult(run) {
-    return JSON.stringify({
-        runId: run.id,
-        status: run.status,
-        task: run.task,
-        sessionId: run.sessionId,
-        finalSummary: run.finalSummary,
-        messageCount: run.messages.length,
-        actionCount: run.actions.length,
-        commits: run.commits,
-        context: run.context,
-    }, null, 2);
-}

package/dist/plugin/service-factory.d.ts

@@ -1,7 +1,8 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
-export interface ClaudeManagerPluginServices {
+interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
+export {};

package/dist/plugin/service-factory.js

@@ -3,6 +3,7 @@ import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
 import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
+import { TranscriptStore } from '../state/transcript-store.js';
 import { ContextTracker } from '../manager/context-tracker.js';
 import { GitOperations } from '../manager/git-operations.js';
 import { SessionController } from '../manager/session-controller.js';
@@ -21,7 +22,8 @@ export function getOrCreatePluginServices(worktree) {
     const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
-    const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker);
+    const transcriptStore = new TranscriptStore();
+    const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
     // Try to restore active session state (fire and forget)
     manager.tryRestore(worktree).catch(() => { });
     const services = {

package/dist/state/file-run-state-store.js

@@ -1,6 +1,6 @@
-import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
 export class FileRunStateStore {
     baseDirectoryName;
     writeQueues = new Map();
@@ -85,13 +85,3 @@ export class FileRunStateStore {
         }
     }
 }
-async function writeJsonAtomically(filePath, data) {
-    const tempPath = `${filePath}.${randomUUID()}.tmp`;
-    await fs.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
-    await fs.rename(tempPath, filePath);
-}
-function isFileNotFoundError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        error.code === 'ENOENT');
-}

package/dist/state/transcript-store.d.ts

@@ -0,0 +1,15 @@
+import type { ClaudeSessionEvent } from '../types/contracts.js';
+export declare class TranscriptStore {
+    private readonly baseDirectoryName;
+    constructor(baseDirectoryName?: string);
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    appendEvents(cwd: string, sessionId: string, newEvents: ClaudeSessionEvent[]): Promise<void>;
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    readEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
+    private getTranscriptPath;
+}

package/dist/state/transcript-store.js

@@ -0,0 +1,44 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
+export class TranscriptStore {
+    baseDirectoryName;
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    async appendEvents(cwd, sessionId, newEvents) {
+        if (newEvents.length === 0) {
+            return;
+        }
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        const existing = await this.readEvents(cwd, sessionId);
+        const merged = appendTranscriptEvents(existing, newEvents);
+        const cleaned = stripTrailingPartials(merged);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, cleaned);
+    }
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    async readEvents(cwd, sessionId) {
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    getTranscriptPath(cwd, sessionId) {
+        return path.join(cwd, this.baseDirectoryName, 'transcripts', `${sessionId}.json`);
+    }
+}

package/dist/util/fs-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJsonAtomically(filePath: string, data: unknown): Promise<void>;
+export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;

package/dist/util/fs-helpers.js

@@ -0,0 +1,12 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+export async function writeJsonAtomically(filePath, data) {
+    const tempPath = `${filePath}.${randomUUID()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+    await fs.rename(tempPath, filePath);
+}
+export function isFileNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -40,6 +40,7 @@
     "@vitest/coverage-v8": "^4.1.0",
     "eslint": "^9.22.0",
     "globals": "^15.15.0",
+    "knip": "^6.0.2",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.1",
@@ -51,6 +52,7 @@
     "lint": "eslint .",
     "format": "prettier --write .",
     "test": "vitest run",
+    "knip": "knip",
     "release": "pnpm run build && pnpm version patch && pnpm publish"
   }
 }