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

package/dist/src/team/roster.js

@@ -1,40 +0,0 @@
-import { DEFAULT_ENGINEER_NAMES, PLANNER_ELIGIBLE_ENGINEERS, } from '../types/contracts.js';
-const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
-export { PLANNER_ELIGIBLE_ENGINEERS };
-export function isEngineerName(value) {
-    return TEAM_ENGINEERS.includes(value);
-}
-export function createEmptyTeamRecord(teamId, cwd) {
-    const timestamp = new Date().toISOString();
-    return {
-        id: teamId,
-        cwd,
-        createdAt: timestamp,
-        updatedAt: timestamp,
-        engineers: TEAM_ENGINEERS.map((name) => createEmptyEngineerRecord(name)),
-    };
-}
-export function createEmptyEngineerRecord(name) {
-    return {
-        name,
-        wrapperSessionId: null,
-        claudeSessionId: null,
-        busy: false,
-        busySince: null,
-        lastMode: null,
-        lastTaskSummary: null,
-        lastUsedAt: null,
-        wrapperHistory: [],
-        context: {
-            sessionId: null,
-            totalTurns: 0,
-            totalCostUsd: 0,
-            latestInputTokens: null,
-            latestOutputTokens: null,
-            contextWindowSize: null,
-            estimatedContextPercent: null,
-            warningLevel: 'ok',
-            compactionCount: 0,
-        },
-    };
-}

package/dist/src/types/contracts.d.ts

@@ -1,261 +0,0 @@
-export interface ManagerPromptRegistry {
-    ctoSystemPrompt: string;
-    engineerAgentPrompt: string;
-    engineerSessionPrompt: string;
-    /** Prompt prepended to the user prompt of the synthesis runTask call inside plan_with_team. */
-    planSynthesisPrompt: string;
-    /** Visible subagent prompt for teamPlanner — thin wrapper that calls plan_with_team. */
-    teamPlannerPrompt: string;
-    /** Visible subagent prompt for browserQa — thin wrapper that calls claude tool for browser verification. */
-    browserQaAgentPrompt: string;
-    /** Prompt prepended to browser verification task prompts in Claude Code sessions. */
-    browserQaSessionPrompt: string;
-    contextWarnings: {
-        moderate: string;
-        high: string;
-        critical: string;
-    };
-}
-export type SessionMode = 'plan' | 'free';
-export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
-export declare const PLANNER_ELIGIBLE_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-export type EngineerName = (typeof DEFAULT_ENGINEER_NAMES)[number];
-export type EngineerWorkMode = 'explore' | 'implement' | 'verify';
-export interface WrapperHistoryEntry {
-    timestamp: string;
-    type: 'assignment' | 'result';
-    mode?: EngineerWorkMode;
-    text: string;
-}
-interface ClaudeCommandMetadata {
-    name: string;
-    description: string;
-    argumentHint?: string;
-    source: 'sdk' | 'skill' | 'command';
-    path?: string;
-}
-interface ClaudeAgentMetadata {
-    name: string;
-    description: string;
-    model?: string;
-    source: 'sdk' | 'filesystem';
-}
-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';
-    /**
-     * When true, the canUseTool callback denies write tools (Edit, Write, MultiEdit,
-     * NotebookEdit) and destructive bash commands. Used instead of SDK plan mode so
-     * the agent can still exit plan mode if needed.
-     */
-    restrictWriteTools?: boolean;
-    /** 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?: Array<'user' | 'project' | 'local'>;
-    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 type TaskSize = 'trivial' | 'simple' | 'large';
-export interface PlanSlice {
-    index: number;
-    description: string;
-    status: 'pending' | 'in_progress' | 'done' | 'skipped';
-    completedAt?: string;
-}
-export interface ActivePlan {
-    id: string;
-    summary: string;
-    taskSize: TaskSize;
-    createdAt: string;
-    confirmedAt: string | null;
-    preAuthorized: boolean;
-    slices: PlanSlice[];
-    /** Null when the plan has no slices (trivial/simple tasks). */
-    currentSliceIndex: number | null;
-}
-export interface TeamEngineerRecord {
-    name: EngineerName;
-    wrapperSessionId: string | null;
-    claudeSessionId: string | null;
-    busy: boolean;
-    busySince: string | null;
-    lastMode: EngineerWorkMode | null;
-    lastTaskSummary: string | null;
-    lastUsedAt: string | null;
-    wrapperHistory: WrapperHistoryEntry[];
-    context: SessionContextSnapshot;
-}
-export type EngineerFailureKind = 'sdkError' | 'contextExhausted' | 'toolDenied' | 'modeNotSupported' | 'aborted' | 'engineerBusy' | 'unknown';
-export interface EngineerFailureResult {
-    teamId: string;
-    engineer: EngineerName;
-    mode: EngineerWorkMode;
-    failureKind: EngineerFailureKind;
-    message: string;
-}
-export interface TeamRecord {
-    id: string;
-    cwd: string;
-    createdAt: string;
-    updatedAt: string;
-    engineers: TeamEngineerRecord[];
-    activePlan?: ActivePlan;
-}
-export interface EngineerTaskResult {
-    teamId: string;
-    engineer: EngineerName;
-    mode: EngineerWorkMode;
-    sessionId?: string;
-    finalText: string;
-    turns?: number;
-    totalCostUsd?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    contextWindowSize?: number;
-    context: SessionContextSnapshot;
-}
-export interface PlanDraft extends EngineerTaskResult {
-    request: string;
-}
-export interface SynthesizedPlanResult {
-    teamId: string;
-    request: string;
-    leadEngineer: EngineerName;
-    challengerEngineer: EngineerName;
-    drafts: [PlanDraft, PlanDraft];
-    synthesis: string;
-    recommendedQuestion: string | null;
-    recommendedAnswer: string | null;
-}
-/**
- * Per-worker capability config for behavior that differs from the standard engineer path.
- * Keyed by EngineerName in a Partial<Record<EngineerName, WorkerCapabilities>> map;
- * absent entries use default behavior.
- */
-export interface WorkerCapabilities {
-    /** Override the session system prompt for this worker. Absent = use standard engineer prompt. */
-    sessionPrompt?: string;
-    /** Always restrict write tools regardless of mode. Default: false. */
-    restrictWriteTools?: boolean;
-    /** Skip mode instructions in the task prompt. Default: false. */
-    skipModeInstructions?: boolean;
-    /** Allow this worker in plan_with_team. Absent or true = eligible. False = excluded. */
-    plannerEligible?: boolean;
-    /** Returns true if the final output indicates the required runtime is unavailable. */
-    isRuntimeUnavailableResponse?: (finalText: string) => boolean;
-    /** Metadata title for the runtime-unavailable event. */
-    runtimeUnavailableTitle?: string;
-    /**
-     * Explicit SDK-level pre-approval list for this worker's inner Claude Code session.
-     * Tools in this list bypass interactive confirmation prompts (they are still subject to
-     * the `canUseTool` write-restriction and approval-policy filters).
-     * Absent = falls back to `['Skill']` via the default adapter behaviour.
-     */
-    sessionAllowedTools?: string[];
-}
-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 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[];
-    /**
-     * Always `allow`: tools that do not match any rule are allowed.
-     * Blocking is done only with explicit `deny` rules (deny-list contract).
-     */
-    defaultAction: 'allow';
-    defaultDenyMessage?: string;
-    enabled: boolean;
-}
-export interface ToolApprovalDecision {
-    timestamp: string;
-    toolName: string;
-    inputPreview: string;
-    title?: string;
-    matchedRuleId: string;
-    action: 'allow' | 'deny';
-    denyMessage?: string;
-    agentId?: string;
-}
-export {};

package/dist/src/types/contracts.js

@@ -1,2 +0,0 @@
-export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA'];
-export const PLANNER_ELIGIBLE_ENGINEERS = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];

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

@@ -1,8 +0,0 @@
-export declare function writeJsonAtomically(filePath: string, data: unknown): Promise<void>;
-export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;
-/**
- * Appends a single NDJSON line to a debug log file.
- * Creates the parent directory if it does not exist.
- * A `ts` (ISO timestamp) field is injected automatically.
- */
-export declare function appendDebugLog(logPath: string, entry: Record<string, unknown>): Promise<void>;

package/dist/src/util/fs-helpers.js

@@ -1,21 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-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');
-}
-/**
- * Appends a single NDJSON line to a debug log file.
- * Creates the parent directory if it does not exist.
- * A `ts` (ISO timestamp) field is injected automatically.
- */
-export async function appendDebugLog(logPath, entry) {
-    const line = JSON.stringify({ ...entry, ts: new Date().toISOString() }) + '\n';
-    await fs.mkdir(path.dirname(logPath), { recursive: true });
-    await fs.appendFile(logPath, line, 'utf8');
-}

package/dist/src/util/project-context.d.ts

@@ -1,10 +0,0 @@
-import type { DiscoveredClaudeFile } from '../types/contracts.js';
-/**
- * Recursively discover all project-level Claude files:
- *   - every `CLAUDE.md` found anywhere in the repo tree
- *   - every file under `.claude/` recursively
- *
- * Returns a de-duplicated, deterministically sorted array of
- * { relativePath, content } entries. Empty/blank files are skipped.
- */
-export declare function discoverProjectClaudeFiles(cwd: string): Promise<DiscoveredClaudeFile[]>;

package/dist/src/util/project-context.js

@@ -1,105 +0,0 @@
-import { readFile, readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { isFileNotFoundError } from './fs-helpers.js';
-/**
- * Recursively discover all project-level Claude files:
- *   - every `CLAUDE.md` found anywhere in the repo tree
- *   - every file under `.claude/` recursively
- *
- * Returns a de-duplicated, deterministically sorted array of
- * { relativePath, content } entries. Empty/blank files are skipped.
- */
-export async function discoverProjectClaudeFiles(cwd) {
-    const seen = new Set();
-    const results = [];
-    // 1. Walk the entire tree for CLAUDE.md files.
-    await walkForClaudeMd(cwd, cwd, seen, results);
-    // 2. Walk .claude/ recursively for any file.
-    await walkDotClaudeDir(cwd, seen, results);
-    // Deterministic: sort by relativePath (lexicographic).
-    results.sort((a, b) => a.relativePath < b.relativePath ? -1 : a.relativePath > b.relativePath ? 1 : 0);
-    return results;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/** Recursively walk `dir` looking for files named `CLAUDE.md`. */
-async function walkForClaudeMd(root, dir, seen, out) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch (err) {
-        if (isFileNotFoundError(err))
-            return;
-        throw err;
-    }
-    for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            // Skip node_modules, .git, and hidden dirs other than .claude
-            if (entry.name === 'node_modules' || entry.name === '.git')
-                continue;
-            await walkForClaudeMd(root, fullPath, seen, out);
-        }
-        else if (entry.name === 'CLAUDE.md') {
-            const rel = toForwardSlash(relative(root, fullPath));
-            if (seen.has(rel))
-                continue;
-            const content = await tryReadText(fullPath);
-            if (content !== null) {
-                seen.add(rel);
-                out.push({ relativePath: rel, content });
-            }
-        }
-    }
-}
-/** Recursively walk `.claude/` and collect every file. */
-async function walkDotClaudeDir(root, seen, out) {
-    const dotClaudeDir = join(root, '.claude');
-    await walkAllFiles(root, dotClaudeDir, seen, out);
-}
-/** Recursively collect all files under `dir`. */
-async function walkAllFiles(root, dir, seen, out) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch (err) {
-        if (isFileNotFoundError(err))
-            return;
-        throw err;
-    }
-    for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            await walkAllFiles(root, fullPath, seen, out);
-        }
-        else if (entry.isFile()) {
-            const rel = toForwardSlash(relative(root, fullPath));
-            if (seen.has(rel))
-                continue;
-            const content = await tryReadText(fullPath);
-            if (content !== null) {
-                seen.add(rel);
-                out.push({ relativePath: rel, content });
-            }
-        }
-    }
-}
-/** Read a file as UTF-8, returning trimmed content or null if empty/missing. */
-async function tryReadText(filePath) {
-    try {
-        const raw = await readFile(filePath, 'utf-8');
-        const trimmed = raw.trim();
-        return trimmed.length > 0 ? trimmed : null;
-    }
-    catch (err) {
-        if (isFileNotFoundError(err))
-            return null;
-        throw err;
-    }
-}
-function toForwardSlash(p) {
-    return p.replace(/\\/g, '/');
-}

package/dist/src/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/src/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/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,85 +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/test/claude-agent-sdk-adapter.test.d.ts

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