@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

package/dist/claude/session-live-tailer.js

@@ -1,269 +0,0 @@
-import { createReadStream, existsSync, readdirSync, statSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import path from 'node:path';
-import os from 'node:os';
-/**
- * Tails Claude Code session JSONL files for live tool output.
- *
- * The SDK streams high-level events (assistant text, tool_call summaries, results)
- * but does not expose the raw tool output that Claude Code writes to the JSONL
- * transcript on disk.  This service fills that gap by polling the file for new
- * lines, parsing each one, and forwarding parsed events to a caller-supplied
- * callback.
- */
-export class SessionLiveTailer {
-    activeTails = new Map();
-    // ── Path discovery ──────────────────────────────────────────────────
-    /**
-     * Locate the JSONL file for a session.
-     *
-     * Claude Code stores transcripts at:
-     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
-     *
-     * The `<sanitized-cwd>` folder name is an internal implementation detail that
-     * can change across Claude Code versions, so we search all project directories
-     * for the session file rather than attempting to replicate the sanitisation.
-     */
-    findSessionFile(sessionId, cwd) {
-        const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-        if (!existsSync(projectsDir)) {
-            return null;
-        }
-        // If cwd is provided, try the sanitised form first (best-effort fast path).
-        if (cwd) {
-            const sanitised = cwd.replace(/\//g, '-');
-            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        // Fall back to scanning all project directories.
-        try {
-            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
-                if (!entry.isDirectory())
-                    continue;
-                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
-                if (existsSync(candidate)) {
-                    return candidate;
-                }
-            }
-        }
-        catch {
-            // Permission denied or similar — nothing we can do.
-        }
-        return null;
-    }
-    /**
-     * Check whether we can locate a JSONL file for the given session.
-     */
-    sessionFileExists(sessionId, cwd) {
-        return this.findSessionFile(sessionId, cwd) !== null;
-    }
-    // ── Live tailing ────────────────────────────────────────────────────
-    /**
-     * Poll a session's JSONL file for new lines and emit parsed events.
-     *
-     * Returns a stop function.  The caller **must** invoke it when tailing is no
-     * longer needed (e.g. when the session completes or the tool is interrupted).
-     */
-    startTailing(sessionId, cwd, onEvent, pollIntervalMs = 150) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath) {
-            onEvent({
-                type: 'error',
-                sessionId,
-                error: `Session JSONL not found for ${sessionId}`,
-            });
-            return () => { };
-        }
-        let offset = statSync(filePath).size;
-        let buffer = '';
-        let reading = false; // guard against overlapping reads
-        const interval = setInterval(() => {
-            if (reading)
-                return;
-            try {
-                const currentSize = statSync(filePath).size;
-                if (currentSize < offset) {
-                    // File was truncated (rotation / compaction) — reset.
-                    offset = 0;
-                    buffer = '';
-                }
-                if (currentSize <= offset)
-                    return;
-                reading = true;
-                const stream = createReadStream(filePath, {
-                    start: offset,
-                    end: currentSize - 1,
-                    encoding: 'utf8',
-                });
-                let chunk = '';
-                stream.on('data', (data) => {
-                    chunk += typeof data === 'string' ? data : data.toString('utf8');
-                });
-                stream.on('end', () => {
-                    reading = false;
-                    offset = currentSize;
-                    buffer += chunk;
-                    const lines = buffer.split('\n');
-                    // Keep the last (possibly incomplete) segment in the buffer.
-                    buffer = lines.pop() ?? '';
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            continue;
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: parsed,
-                                rawLine: trimmed,
-                            });
-                        }
-                        catch {
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: null,
-                                rawLine: trimmed,
-                            });
-                        }
-                    }
-                });
-                stream.on('error', (err) => {
-                    reading = false;
-                    onEvent({
-                        type: 'error',
-                        sessionId,
-                        error: err.message,
-                    });
-                });
-            }
-            catch (err) {
-                reading = false;
-                onEvent({
-                    type: 'error',
-                    sessionId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }, pollIntervalMs);
-        this.activeTails.set(sessionId, interval);
-        return () => this.stopTailing(sessionId);
-    }
-    /**
-     * Stop tailing a specific session.
-     */
-    stopTailing(sessionId) {
-        const interval = this.activeTails.get(sessionId);
-        if (interval) {
-            clearInterval(interval);
-            this.activeTails.delete(sessionId);
-        }
-    }
-    /**
-     * Stop all active tails (cleanup on shutdown).
-     */
-    stopAll() {
-        for (const [, interval] of this.activeTails) {
-            clearInterval(interval);
-        }
-        this.activeTails.clear();
-    }
-    // ── Snapshot helpers ────────────────────────────────────────────────
-    /**
-     * Read the last N lines from a session JSONL file.
-     */
-    async getLastLines(sessionId, cwd, lineCount = 20) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath)
-            return [];
-        const lines = [];
-        const rl = createInterface({
-            input: createReadStream(filePath, { encoding: 'utf8' }),
-        });
-        for await (const line of rl) {
-            lines.push(line);
-            if (lines.length > lineCount) {
-                lines.shift();
-            }
-        }
-        return lines;
-    }
-    /**
-     * Extract a preview of recent tool output from the tail of a session file.
-     */
-    async getToolOutputPreview(sessionId, cwd, maxEntries = 5) {
-        const lastLines = await this.getLastLines(sessionId, cwd, 100);
-        const previews = [];
-        for (const line of lastLines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                const preview = extractToolOutput(parsed);
-                if (preview) {
-                    previews.push(preview);
-                }
-            }
-            catch {
-                // skip unparseable lines
-            }
-        }
-        return previews.slice(-maxEntries);
-    }
-}
-// ── Internal helpers ────────────────────────────────────────────────────
-/**
- * Attempt to extract tool output information from a JSONL record.
- *
- * Claude Code JSONL records with tool results can appear as:
- *   1. A top-level `{ type: "user", message: { content: [{ type: "tool_result", ... }] } }`
- *   2. Direct `tool_result` entries (less common).
- */
-function extractToolOutput(record) {
-    // Pattern 1: user message wrapping tool_result content blocks
-    if (record.type === 'user') {
-        const message = record.message;
-        if (!message)
-            return null;
-        const content = message.content;
-        if (!Array.isArray(content))
-            return null;
-        for (const block of content) {
-            if (block &&
-                typeof block === 'object' &&
-                block.type === 'tool_result') {
-                const b = block;
-                return {
-                    toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
-                    content: stringifyContent(b.content),
-                    isError: b.is_error === true,
-                };
-            }
-        }
-    }
-    // Pattern 2: direct tool_result record (varies by Claude Code version)
-    if (record.type === 'tool_result') {
-        return {
-            toolUseId: typeof record.tool_use_id === 'string' ? record.tool_use_id : '',
-            content: stringifyContent(record.content),
-            isError: record.is_error === true,
-        };
-    }
-    return null;
-}
-function stringifyContent(value) {
-    if (typeof value === 'string')
-        return value;
-    if (value === undefined || value === null)
-        return '';
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return '[non-serializable]';
-    }
-}

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

@@ -1,41 +0,0 @@
-import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
-import type { ClaudeSessionRunResult, SessionContextSnapshot, SessionMode } from '../types/contracts.js';
-import type { ContextTracker } from './context-tracker.js';
-export declare class SessionController {
-    private readonly sdkAdapter;
-    private readonly contextTracker;
-    private readonly sessionPrompt;
-    private readonly wrapperType;
-    private readonly worktree;
-    private readonly modePrefixes;
-    private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
-        plan: string;
-        free: string;
-    });
-    get isActive(): boolean;
-    get sessionId(): string | null;
-    /**
-     * Send a message to the persistent session. Creates one if none exists.
-     * Returns the session result including usage data.
-     */
-    sendMessage(message: string, options?: {
-        model?: string;
-        effort?: 'low' | 'medium' | 'high' | 'max';
-        mode?: SessionMode;
-        sessionSystemPrompt?: string;
-        abortSignal?: AbortSignal;
-    }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    clearSession(): Promise<string | null>;
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot(): SessionContextSnapshot;
-}

package/dist/manager/session-controller.js

@@ -1,97 +0,0 @@
-export class SessionController {
-    sdkAdapter;
-    contextTracker;
-    sessionPrompt;
-    wrapperType;
-    worktree;
-    modePrefixes;
-    activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
-        plan: '',
-        free: '',
-    }) {
-        this.sdkAdapter = sdkAdapter;
-        this.contextTracker = contextTracker;
-        this.sessionPrompt = sessionPrompt;
-        this.wrapperType = wrapperType;
-        this.worktree = worktree;
-        this.modePrefixes = modePrefixes;
-    }
-    get isActive() {
-        return this.activeSessionId !== null;
-    }
-    get sessionId() {
-        return this.activeSessionId;
-    }
-    /**
-     * Send a message to the persistent session. Creates one if none exists.
-     * Returns the session result including usage data.
-     */
-    async sendMessage(message, options, onEvent) {
-        const mode = options?.mode ?? 'free';
-        const prefix = this.modePrefixes[mode];
-        const prompt = prefix ? `${prefix}\n\n${message}` : message;
-        const input = {
-            cwd: this.worktree,
-            prompt,
-            persistSession: true,
-            permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
-            includePartialMessages: true,
-            model: options?.model,
-            effort: options?.effort,
-            settingSources: ['user'],
-            abortSignal: options?.abortSignal,
-        };
-        if (this.activeSessionId) {
-            // Resume existing session
-            input.resumeSessionId = this.activeSessionId;
-        }
-        else {
-            // New session — prefer dynamically constructed prompt from wrapper, fall back to static default
-            input.systemPrompt = options?.sessionSystemPrompt ?? this.sessionPrompt;
-            input.model ??= 'claude-opus-4-6';
-            input.effort ??= 'high';
-        }
-        const result = await this.sdkAdapter.runSession(input, onEvent);
-        // Track the session ID
-        if (result.sessionId) {
-            this.activeSessionId = result.sessionId;
-        }
-        // Update context tracking
-        this.contextTracker.recordResult({
-            sessionId: result.sessionId,
-            turns: result.turns,
-            totalCostUsd: result.totalCostUsd,
-            inputTokens: result.inputTokens,
-            outputTokens: result.outputTokens,
-            contextWindowSize: result.contextWindowSize,
-        });
-        return result;
-    }
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    async compactSession(onEvent) {
-        if (!this.activeSessionId) {
-            throw new Error('No active session to compact');
-        }
-        const result = await this.sendMessage('/compact', undefined, onEvent);
-        this.contextTracker.recordCompaction();
-        return result;
-    }
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    async clearSession() {
-        const clearedId = this.activeSessionId;
-        this.activeSessionId = null;
-        this.contextTracker.reset();
-        return clearedId;
-    }
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot() {
-        return this.contextTracker.snapshot();
-    }
-}

package/dist/metadata/claude-metadata.service.d.ts

@@ -1,12 +0,0 @@
-import type { ClaudeMetadataSnapshot, ClaudeSettingSource } from '../types/contracts.js';
-import type { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
-import type { RepoClaudeConfigReader } from './repo-claude-config-reader.js';
-export declare class ClaudeMetadataService {
-    private readonly configReader;
-    private readonly sdkAdapter;
-    constructor(configReader: RepoClaudeConfigReader, sdkAdapter: ClaudeAgentSdkAdapter);
-    collect(cwd: string, options?: {
-        includeSdkProbe?: boolean;
-        settingSources?: ClaudeSettingSource[];
-    }): Promise<ClaudeMetadataSnapshot>;
-}

package/dist/metadata/claude-metadata.service.js

@@ -1,38 +0,0 @@
-export class ClaudeMetadataService {
-    configReader;
-    sdkAdapter;
-    constructor(configReader, sdkAdapter) {
-        this.configReader = configReader;
-        this.sdkAdapter = sdkAdapter;
-    }
-    async collect(cwd, options = {}) {
-        const baseSnapshot = await this.configReader.read(cwd);
-        if (!options.includeSdkProbe) {
-            return dedupeSnapshot(baseSnapshot);
-        }
-        const capabilities = await this.sdkAdapter.probeCapabilities(cwd, options.settingSources);
-        return dedupeSnapshot({
-            ...baseSnapshot,
-            commands: [...baseSnapshot.commands, ...capabilities.commands],
-            agents: capabilities.agents,
-        });
-    }
-}
-function dedupeSnapshot(snapshot) {
-    return {
-        ...snapshot,
-        commands: dedupeByName(snapshot.commands),
-        skills: dedupeByName(snapshot.skills),
-        hooks: dedupeByName(snapshot.hooks),
-        agents: dedupeByName(snapshot.agents),
-    };
-}
-function dedupeByName(items) {
-    const seen = new Map();
-    for (const item of items) {
-        if (!seen.has(item.name)) {
-            seen.set(item.name, item);
-        }
-    }
-    return [...seen.values()].sort((left, right) => left.name.localeCompare(right.name));
-}

package/dist/metadata/repo-claude-config-reader.d.ts

@@ -1,7 +0,0 @@
-import type { ClaudeMetadataSnapshot } from '../types/contracts.js';
-export declare class RepoClaudeConfigReader {
-    read(cwd: string): Promise<ClaudeMetadataSnapshot>;
-    private readSkills;
-    private readCommands;
-    private readSettings;
-}

package/dist/metadata/repo-claude-config-reader.js

@@ -1,154 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import JSON5 from 'json5';
-export class RepoClaudeConfigReader {
-    async read(cwd) {
-        const claudeDirectory = path.join(cwd, '.claude');
-        const skillsDirectory = path.join(claudeDirectory, 'skills');
-        const commandsDirectory = path.join(claudeDirectory, 'commands');
-        const claudeMdCandidates = [
-            path.join(cwd, 'CLAUDE.md'),
-            path.join(claudeDirectory, 'CLAUDE.md'),
-        ];
-        const collectedAt = new Date().toISOString();
-        const [skills, commands, settingsResult, claudeMdPath] = await Promise.all([
-            this.readSkills(skillsDirectory),
-            this.readCommands(commandsDirectory),
-            this.readSettings(claudeDirectory),
-            findFirstExistingPath(claudeMdCandidates),
-        ]);
-        return {
-            collectedAt,
-            cwd,
-            commands: [...skillsToCommands(skills), ...commands],
-            skills,
-            hooks: settingsResult.hooks,
-            agents: [],
-            claudeMdPath: claudeMdPath ?? undefined,
-            settingsPaths: settingsResult.settingsPaths,
-        };
-    }
-    async readSkills(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const entries = await fs.readdir(directory, { withFileTypes: true });
-        const skills = await Promise.all(entries
-            .filter((entry) => entry.isDirectory())
-            .map(async (entry) => {
-            const skillPath = path.join(directory, entry.name, 'SKILL.md');
-            if (!(await pathExists(skillPath))) {
-                return null;
-            }
-            const content = await fs.readFile(skillPath, 'utf8');
-            return {
-                name: entry.name,
-                description: extractMarkdownDescription(content),
-                path: skillPath,
-                source: 'skill',
-            };
-        }));
-        return skills.filter((skill) => skill !== null);
-    }
-    async readCommands(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const commandFiles = await collectMarkdownFiles(directory);
-        const commands = await Promise.all(commandFiles.map(async (commandPath) => {
-            const content = await fs.readFile(commandPath, 'utf8');
-            return {
-                name: path.basename(commandPath, path.extname(commandPath)),
-                description: extractMarkdownDescription(content),
-                source: 'command',
-                path: commandPath,
-            };
-        }));
-        return commands.sort((left, right) => left.name.localeCompare(right.name));
-    }
-    async readSettings(claudeDirectory) {
-        const candidatePaths = [
-            path.join(claudeDirectory, 'settings.json'),
-            path.join(claudeDirectory, 'settings.local.json'),
-        ];
-        const settingsPaths = [];
-        const hooks = [];
-        for (const candidatePath of candidatePaths) {
-            if (!(await pathExists(candidatePath))) {
-                continue;
-            }
-            settingsPaths.push(candidatePath);
-            const content = await fs.readFile(candidatePath, 'utf8');
-            const parsed = JSON5.parse(content);
-            const hookEntries = Object.entries(parsed.hooks ?? {});
-            for (const [hookName, hookValue] of hookEntries) {
-                const hookMatchers = Array.isArray(hookValue) ? hookValue : [hookValue];
-                for (const hookMatcher of hookMatchers) {
-                    if (!hookMatcher || typeof hookMatcher !== 'object') {
-                        continue;
-                    }
-                    const matcher = typeof hookMatcher.matcher === 'string'
-                        ? hookMatcher.matcher
-                        : undefined;
-                    const commandCount = Array.isArray(hookMatcher.hooks)
-                        ? (hookMatcher.hooks?.length ?? 0)
-                        : 0;
-                    hooks.push({
-                        name: hookName,
-                        matcher,
-                        sourcePath: candidatePath,
-                        commandCount,
-                    });
-                }
-            }
-        }
-        return {
-            settingsPaths,
-            hooks,
-        };
-    }
-}
-function extractMarkdownDescription(markdown) {
-    const lines = markdown
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const descriptionLine = lines.find((line) => !line.startsWith('#') && !line.startsWith('---'));
-    return descriptionLine ?? 'No description provided.';
-}
-async function collectMarkdownFiles(directory) {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const files = await Promise.all(entries.map(async (entry) => {
-        const resolvedPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-            return collectMarkdownFiles(resolvedPath);
-        }
-        return entry.name.endsWith('.md') ? [resolvedPath] : [];
-    }));
-    return files.flat();
-}
-async function pathExists(candidatePath) {
-    try {
-        await fs.access(candidatePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function findFirstExistingPath(candidatePaths) {
-    for (const candidatePath of candidatePaths) {
-        if (await pathExists(candidatePath)) {
-            return candidatePath;
-        }
-    }
-    return null;
-}
-function skillsToCommands(skills) {
-    return skills.map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-        source: 'skill',
-        path: skill.path,
-    }));
-}

package/dist/plugin/orchestrator.plugin.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-export declare const OrchestratorPlugin: Plugin;