@doingdev/opencode-claude-manager-plugin 0.1.20 → 0.1.22

package/dist/plugin/service-factory.js

@@ -1,41 +0,0 @@
-import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
-import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { SessionLiveTailer } from '../claude/session-live-tailer.js';
-import { ToolApprovalManager } from '../claude/tool-approval-manager.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';
-import { PersistentManager } from '../manager/persistent-manager.js';
-import { managerPromptRegistry } from '../prompts/registry.js';
-const serviceCache = new Map();
-export function getOrCreatePluginServices(worktree) {
-    const cachedServices = serviceCache.get(worktree);
-    if (cachedServices) {
-        return cachedServices;
-    }
-    const approvalManager = new ToolApprovalManager();
-    const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
-    const metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
-    const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
-    const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt, managerPromptRegistry.modePrefixes);
-    const gitOps = new GitOperations(worktree);
-    const stateStore = new FileRunStateStore();
-    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 liveTailer = new SessionLiveTailer();
-    const services = {
-        manager,
-        sessions: sessionService,
-        approvalManager,
-        liveTailer,
-    };
-    serviceCache.set(worktree, services);
-    return services;
-}

package/dist/state/file-run-state-store.d.ts

@@ -1,14 +0,0 @@
-import type { PersistentRunRecord } from '../types/contracts.js';
-export declare class FileRunStateStore {
-    private readonly baseDirectoryName;
-    private readonly writeQueues;
-    constructor(baseDirectoryName?: string);
-    saveRun(run: PersistentRunRecord): Promise<void>;
-    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
-    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
-    updateRun(cwd: string, runId: string, update: (run: PersistentRunRecord) => PersistentRunRecord): Promise<PersistentRunRecord>;
-    private getRunKey;
-    private getRunsDirectory;
-    private getRunPath;
-    private enqueueWrite;
-}

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

@@ -1,87 +0,0 @@
-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();
-    constructor(baseDirectoryName = '.claude-manager') {
-        this.baseDirectoryName = baseDirectoryName;
-    }
-    async saveRun(run) {
-        await this.enqueueWrite(this.getRunKey(run.cwd, run.id), async () => {
-            const runPath = this.getRunPath(run.cwd, run.id);
-            await fs.mkdir(path.dirname(runPath), { recursive: true });
-            await writeJsonAtomically(runPath, run);
-        });
-    }
-    async getRun(cwd, runId) {
-        const runPath = this.getRunPath(cwd, runId);
-        try {
-            const content = await fs.readFile(runPath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async listRuns(cwd) {
-        const runsDirectory = this.getRunsDirectory(cwd);
-        try {
-            const entries = await fs.readdir(runsDirectory);
-            const runs = await Promise.all(entries
-                .filter((entry) => entry.endsWith('.json'))
-                .map(async (entry) => {
-                const content = await fs.readFile(path.join(runsDirectory, entry), 'utf8');
-                return JSON.parse(content);
-            }));
-            return runs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return [];
-            }
-            throw error;
-        }
-    }
-    async updateRun(cwd, runId, update) {
-        return this.enqueueWrite(this.getRunKey(cwd, runId), async () => {
-            const existingRun = await this.getRun(cwd, runId);
-            if (!existingRun) {
-                throw new Error(`Run ${runId} does not exist.`);
-            }
-            const updatedRun = update(existingRun);
-            const runPath = this.getRunPath(cwd, runId);
-            await fs.mkdir(path.dirname(runPath), { recursive: true });
-            await writeJsonAtomically(runPath, updatedRun);
-            return updatedRun;
-        });
-    }
-    getRunKey(cwd, runId) {
-        return `${cwd}:${runId}`;
-    }
-    getRunsDirectory(cwd) {
-        return path.join(cwd, this.baseDirectoryName, 'runs');
-    }
-    getRunPath(cwd, runId) {
-        return path.join(this.getRunsDirectory(cwd), `${runId}.json`);
-    }
-    async enqueueWrite(key, operation) {
-        const previousOperation = this.writeQueues.get(key) ?? Promise.resolve();
-        const resultPromise = previousOperation
-            .catch(() => undefined)
-            .then(operation);
-        const settledPromise = resultPromise.then(() => undefined, () => undefined);
-        this.writeQueues.set(key, settledPromise);
-        try {
-            return await resultPromise;
-        }
-        finally {
-            if (this.writeQueues.get(key) === settledPromise) {
-                this.writeQueues.delete(key);
-            }
-        }
-    }
-}

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

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/types/contracts.d.ts

@@ -1,215 +0,0 @@
-export interface ManagerPromptRegistry {
-    managerSystemPrompt: string;
-    claudeCodeSessionPrompt: string;
-    modePrefixes: {
-        plan: string;
-        free: string;
-    };
-    contextWarnings: {
-        moderate: string;
-        high: string;
-        critical: string;
-    };
-}
-export type ClaudeSettingSource = 'user' | 'project' | 'local';
-export type SessionMode = 'plan' | 'free';
-export interface ClaudeCommandMetadata {
-    name: string;
-    description: string;
-    argumentHint?: string;
-    source: 'sdk' | 'skill' | 'command';
-    path?: string;
-}
-export interface ClaudeSkillMetadata {
-    name: string;
-    description: string;
-    path: string;
-    source: 'skill' | 'command';
-}
-export interface ClaudeHookMetadata {
-    name: string;
-    matcher?: string;
-    sourcePath: string;
-    commandCount: number;
-}
-export interface ClaudeAgentMetadata {
-    name: string;
-    description: string;
-    model?: string;
-    source: 'sdk' | 'filesystem';
-}
-export interface ClaudeMetadataSnapshot {
-    collectedAt: string;
-    cwd: string;
-    commands: ClaudeCommandMetadata[];
-    skills: ClaudeSkillMetadata[];
-    hooks: ClaudeHookMetadata[];
-    agents: ClaudeAgentMetadata[];
-    claudeMdPath?: string;
-    settingsPaths: string[];
-}
-export interface ClaudeSessionEvent {
-    type: 'init' | 'assistant' | 'partial' | 'user' | 'tool_call' | 'tool_progress' | 'tool_summary' | 'status' | 'system' | 'result' | 'error';
-    sessionId?: string;
-    text: string;
-    turns?: number;
-    totalCostUsd?: number;
-    /** Present on live SDK-normalized events; omitted when compact-persisted to save space. */
-    rawType?: string;
-}
-export interface RunClaudeSessionInput {
-    cwd: string;
-    prompt: string;
-    systemPrompt?: string;
-    model?: string;
-    effort?: 'low' | 'medium' | 'high' | 'max';
-    mode?: SessionMode;
-    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
-    /** Merged with `Skill` by the SDK adapter unless `Skill` appears in `disallowedTools`. */
-    allowedTools?: string[];
-    disallowedTools?: string[];
-    continueSession?: boolean;
-    resumeSessionId?: string;
-    forkSession?: boolean;
-    persistSession?: boolean;
-    includePartialMessages?: boolean;
-    settingSources?: ClaudeSettingSource[];
-    maxTurns?: number;
-    abortSignal?: AbortSignal;
-}
-export interface ClaudeSessionRunResult {
-    sessionId?: string;
-    events: ClaudeSessionEvent[];
-    finalText: string;
-    turns?: number;
-    totalCostUsd?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    contextWindowSize?: number;
-}
-export interface ClaudeSessionSummary {
-    sessionId: string;
-    summary: string;
-    cwd?: string;
-    gitBranch?: string;
-    createdAt?: number;
-    lastModified: number;
-}
-export interface ClaudeSessionTranscriptMessage {
-    role: 'user' | 'assistant';
-    sessionId: string;
-    messageId: string;
-    text: string;
-}
-export interface ClaudeCapabilitySnapshot {
-    commands: ClaudeCommandMetadata[];
-    agents: ClaudeAgentMetadata[];
-    models: string[];
-}
-export type ContextWarningLevel = 'ok' | 'moderate' | 'high' | 'critical';
-export interface SessionContextSnapshot {
-    sessionId: string | null;
-    totalTurns: number;
-    totalCostUsd: number;
-    latestInputTokens: number | null;
-    latestOutputTokens: number | null;
-    contextWindowSize: number | null;
-    estimatedContextPercent: number | null;
-    warningLevel: ContextWarningLevel;
-    compactionCount: number;
-}
-export interface GitDiffResult {
-    hasDiff: boolean;
-    diffText: string;
-    stats: {
-        filesChanged: number;
-        insertions: number;
-        deletions: number;
-    };
-}
-export interface GitOperationResult {
-    success: boolean;
-    output: string;
-    error?: string;
-}
-export interface ActiveSessionState {
-    sessionId: string;
-    cwd: string;
-    startedAt: string;
-    totalTurns: number;
-    totalCostUsd: number;
-    estimatedContextPercent: number | null;
-    contextWindowSize: number | null;
-    latestInputTokens: number | null;
-}
-export type PersistentRunStatus = 'running' | 'completed' | 'failed';
-export interface PersistentRunMessageRecord {
-    timestamp: string;
-    direction: 'sent' | 'received';
-    text: string;
-    turns?: number;
-    totalCostUsd?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-}
-export interface PersistentRunActionRecord {
-    timestamp: string;
-    type: 'git_diff' | 'git_commit' | 'git_reset' | 'compact' | 'clear';
-    result: string;
-}
-export interface PersistentRunRecord {
-    id: string;
-    cwd: string;
-    task: string;
-    status: PersistentRunStatus;
-    createdAt: string;
-    updatedAt: string;
-    sessionId: string | null;
-    sessionHistory: string[];
-    messages: PersistentRunMessageRecord[];
-    actions: PersistentRunActionRecord[];
-    commits: string[];
-    context: SessionContextSnapshot;
-    finalSummary?: string;
-}
-export interface PersistentRunResult {
-    run: PersistentRunRecord;
-}
-export interface LiveTailEvent {
-    type: 'line' | 'error' | 'end';
-    sessionId: string;
-    data?: unknown;
-    rawLine?: string;
-    error?: string;
-}
-export interface ToolOutputPreview {
-    toolUseId: string;
-    content: string;
-    isError: boolean;
-}
-export interface ToolApprovalRule {
-    id: string;
-    description?: string;
-    /** Tool name — exact match or glob with * wildcard */
-    toolPattern: string;
-    /** Optional substring match against JSON-serialized tool input */
-    inputPattern?: string;
-    action: 'allow' | 'deny';
-    denyMessage?: string;
-}
-export interface ToolApprovalPolicy {
-    rules: ToolApprovalRule[];
-    defaultAction: 'allow' | 'deny';
-    defaultDenyMessage?: string;
-    enabled: boolean;
-}
-export interface ToolApprovalDecision {
-    timestamp: string;
-    toolName: string;
-    inputPreview: string;
-    title?: string;
-    matchedRuleId: string;
-    action: 'allow' | 'deny';
-    denyMessage?: string;
-    agentId?: string;
-}

package/dist/types/contracts.js

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

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

@@ -1,2 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/dist/util/transcript-append.d.ts

@@ -1,7 +0,0 @@
-import type { ClaudeSessionEvent } from '../types/contracts.js';
-export declare function stripTrailingPartials(events: ClaudeSessionEvent[]): ClaudeSessionEvent[];
-/**
- * Append transcript events for run-state persistence: at most one trailing
- * `partial`, dropped whenever a non-partial event is appended.
- */
-export declare function appendTranscriptEvents(events: ClaudeSessionEvent[], incoming: ClaudeSessionEvent[]): ClaudeSessionEvent[];

package/dist/util/transcript-append.js

@@ -1,29 +0,0 @@
-export function stripTrailingPartials(events) {
-    let end = events.length;
-    while (end > 0 && events[end - 1].type === 'partial') {
-        end -= 1;
-    }
-    return end === events.length ? events : events.slice(0, end);
-}
-/**
- * Append transcript events for run-state persistence: at most one trailing
- * `partial`, dropped whenever a non-partial event is appended.
- */
-export function appendTranscriptEvents(events, incoming) {
-    let next = events;
-    for (const event of incoming) {
-        if (event.type === 'partial') {
-            if (next.length > 0 && next[next.length - 1].type === 'partial') {
-                next = [...next.slice(0, -1), event];
-            }
-            else {
-                next = [...next, event];
-            }
-        }
-        else {
-            next = stripTrailingPartials(next);
-            next = [...next, event];
-        }
-    }
-    return next;
-}

package/dist/worktree/worktree-coordinator.d.ts

@@ -1,21 +0,0 @@
-import type { WorktreeAssignment } from '../types/contracts.js';
-export interface GitCommandRunner {
-    run(args: string[], cwd: string): Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-}
-export declare class WorktreeCoordinator {
-    private readonly gitRunner;
-    private readonly storageDirectoryName;
-    constructor(gitRunner?: GitCommandRunner, storageDirectoryName?: string);
-    prepareAssignment(input: {
-        cwd: string;
-        runId: string;
-        title: string;
-        useWorktree: boolean;
-    }): Promise<WorktreeAssignment>;
-    cleanupAssignment(assignment: WorktreeAssignment): Promise<void>;
-    isGitRepository(cwd: string): Promise<boolean>;
-    private getRepositoryRoot;
-}

package/dist/worktree/worktree-coordinator.js

@@ -1,64 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-const defaultGitRunner = {
-    run(args, cwd) {
-        return execFileAsync('git', args, { cwd });
-    },
-};
-export class WorktreeCoordinator {
-    gitRunner;
-    storageDirectoryName;
-    constructor(gitRunner = defaultGitRunner, storageDirectoryName = '.claude-manager') {
-        this.gitRunner = gitRunner;
-        this.storageDirectoryName = storageDirectoryName;
-    }
-    async prepareAssignment(input) {
-        const repositoryRoot = await this.getRepositoryRoot(input.cwd);
-        if (!input.useWorktree || !repositoryRoot) {
-            return {
-                mode: 'shared-root',
-                cwd: input.cwd,
-                rootCwd: input.cwd,
-            };
-        }
-        const slug = sanitizeSlug(input.title);
-        const branchName = `claude-manager/${input.runId}-${slug}`;
-        const worktreePath = path.join(repositoryRoot, this.storageDirectoryName, 'worktrees', input.runId, slug);
-        await fs.mkdir(path.dirname(worktreePath), { recursive: true });
-        await this.gitRunner.run(['worktree', 'add', worktreePath, '-b', branchName], repositoryRoot);
-        return {
-            mode: 'git-worktree',
-            cwd: worktreePath,
-            rootCwd: repositoryRoot,
-            branchName,
-        };
-    }
-    async cleanupAssignment(assignment) {
-        if (assignment.mode !== 'git-worktree') {
-            return;
-        }
-        await this.gitRunner.run(['worktree', 'remove', '--force', assignment.cwd], assignment.rootCwd);
-    }
-    async isGitRepository(cwd) {
-        return (await this.getRepositoryRoot(cwd)) !== null;
-    }
-    async getRepositoryRoot(cwd) {
-        try {
-            const result = await this.gitRunner.run(['rev-parse', '--show-toplevel'], cwd);
-            return result.stdout.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    }
-}
-function sanitizeSlug(value) {
-    return (value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 40) || 'task');
-}