@mcoda/mswarm 0.1.56 → 0.1.60

package/dist/vendor/codali/session/SessionStore.js

@@ -0,0 +1,244 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const DEFAULT_SESSION_STORAGE_DIR = ".mcoda/codali/sessions";
+const safeId = (value) => {
+    const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 120);
+    if (!safe)
+        throw new Error("Session id must contain at least one safe character");
+    return safe;
+};
+const parseJsonLines = (content) => {
+    if (!content.trim())
+        return [];
+    return content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+};
+const nowIso = () => new Date().toISOString();
+const shortJson = (value, maxLength = 400) => {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    if (!text)
+        return "";
+    return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+};
+const summarizeEvents = (metadata, events) => {
+    const counts = new Map();
+    for (const event of events)
+        counts.set(event.type, (counts.get(event.type) ?? 0) + 1);
+    const highlights = [];
+    for (const event of events.slice(-20)) {
+        if (event.type === "final" && typeof event.data.content === "string") {
+            highlights.push(`Final: ${shortJson(event.data.content, 240)}`);
+        }
+        else if (event.type === "tool_result") {
+            highlights.push(`Tool ${String(event.data.name ?? "unknown")}: ${String(event.data.ok ?? "unknown")}`);
+        }
+        else if (event.type === "subagent_result") {
+            highlights.push(`Subagent ${String(event.data.role ?? "unknown")}: ${String(event.data.status ?? "unknown")}`);
+        }
+        else if (event.type === "error") {
+            highlights.push(`Error: ${shortJson(event.data.message, 240)}`);
+        }
+    }
+    const countText = Array.from(counts.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([type, count]) => `${type}=${count}`)
+        .join(", ");
+    return {
+        summary: [
+            `Task: ${metadata.task}`,
+            `Status: ${metadata.status}`,
+            `Runs: ${metadata.runIds.join(", ") || "none"}`,
+            `Events: ${countText || "none"}`,
+            highlights.length ? `Recent highlights: ${highlights.join(" | ")}` : "Recent highlights: none",
+        ].join("\n"),
+        highlights,
+    };
+};
+export class SessionStore {
+    constructor(options) {
+        this.lastTimestampMs = 0;
+        this.workspaceRoot = path.resolve(options.workspaceRoot);
+        this.storageDir = options.storageDir ?? DEFAULT_SESSION_STORAGE_DIR;
+    }
+    rootDir() {
+        const resolved = path.resolve(this.workspaceRoot, this.storageDir);
+        const relative = path.relative(this.workspaceRoot, resolved);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            throw new Error("Session storage path is outside workspace root");
+        }
+        return resolved;
+    }
+    sessionDir(sessionId) {
+        return path.join(this.rootDir(), safeId(sessionId));
+    }
+    metadataPath(sessionId) {
+        return path.join(this.sessionDir(sessionId), "metadata.json");
+    }
+    transcriptPath(sessionId) {
+        return path.join(this.sessionDir(sessionId), "transcript.jsonl");
+    }
+    summariesDir(sessionId) {
+        return path.join(this.sessionDir(sessionId), "summaries");
+    }
+    nextTimestampIso(after) {
+        const afterMs = after ? Date.parse(after) : Number.NaN;
+        const timestampMs = Math.max(Date.now(), this.lastTimestampMs + 1, Number.isFinite(afterMs) ? afterMs + 1 : 0);
+        this.lastTimestampMs = timestampMs;
+        return new Date(timestampMs).toISOString();
+    }
+    async createSession(input) {
+        const sessionId = input.sessionId ? safeId(input.sessionId) : randomUUID();
+        const createdAt = this.nextTimestampIso();
+        const metadata = {
+            schemaVersion: 1,
+            sessionId,
+            repoRoot: input.repoRoot,
+            task: input.task,
+            status: input.status ?? "active",
+            branch: input.branch,
+            parentSessionId: input.parentSessionId,
+            runIds: [],
+            transcriptRefs: ["transcript.jsonl"],
+            summaryRefs: [],
+            contextLaneRefs: input.contextLaneRefs ?? [],
+            instructionSources: input.instructionSources ?? [],
+            createdAt,
+            updatedAt: createdAt,
+        };
+        await fs.mkdir(this.sessionDir(sessionId), { recursive: true });
+        await fs.writeFile(this.metadataPath(sessionId), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+        return metadata;
+    }
+    async readSession(sessionId) {
+        const content = await fs.readFile(this.metadataPath(sessionId), "utf8");
+        return JSON.parse(content);
+    }
+    async getOrCreateSession(input) {
+        if (input.sessionId) {
+            try {
+                return await this.readSession(input.sessionId);
+            }
+            catch (error) {
+                if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        return this.createSession(input);
+    }
+    async updateSession(sessionId, patch) {
+        const current = await this.readSession(sessionId);
+        const next = {
+            ...current,
+            ...patch,
+            runIds: patch.runIds ?? current.runIds,
+            transcriptRefs: patch.transcriptRefs ?? current.transcriptRefs,
+            summaryRefs: patch.summaryRefs ?? current.summaryRefs,
+            contextLaneRefs: patch.contextLaneRefs ?? current.contextLaneRefs,
+            instructionSources: patch.instructionSources ?? current.instructionSources,
+            updatedAt: this.nextTimestampIso(current.updatedAt),
+        };
+        await fs.writeFile(this.metadataPath(sessionId), `${JSON.stringify(next, null, 2)}\n`, "utf8");
+        return next;
+    }
+    async addRun(sessionId, runId) {
+        const current = await this.readSession(sessionId);
+        if (current.runIds.includes(runId))
+            return current;
+        return this.updateSession(sessionId, { runIds: [...current.runIds, runId] });
+    }
+    async appendTranscript(sessionId, event) {
+        const record = {
+            schemaVersion: 1,
+            sessionId,
+            type: event.type,
+            timestamp: event.timestamp ?? nowIso(),
+            runId: event.runId,
+            data: event.data,
+        };
+        const transcriptPath = this.transcriptPath(sessionId);
+        await fs.mkdir(path.dirname(transcriptPath), { recursive: true });
+        await fs.appendFile(transcriptPath, `${JSON.stringify(record)}\n`, "utf8");
+        await this.updateSession(sessionId, {});
+        return record;
+    }
+    async readTranscript(sessionId) {
+        try {
+            const content = await fs.readFile(this.transcriptPath(sessionId), "utf8");
+            return parseJsonLines(content);
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async listSessions() {
+        let entries;
+        try {
+            entries = await fs.readdir(this.rootDir());
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        const sessions = [];
+        for (const entry of entries) {
+            try {
+                sessions.push(await this.readSession(entry));
+            }
+            catch {
+                // Ignore incomplete session directories.
+            }
+        }
+        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async compactSession(sessionId) {
+        const metadata = await this.readSession(sessionId);
+        const events = await this.readTranscript(sessionId);
+        const createdAt = nowIso();
+        const compacted = summarizeEvents(metadata, events);
+        const summary = {
+            schemaVersion: 1,
+            sessionId,
+            createdAt,
+            eventCount: events.length,
+            ...compacted,
+        };
+        const summariesDir = this.summariesDir(sessionId);
+        await fs.mkdir(summariesDir, { recursive: true });
+        const fileName = `${createdAt.replace(/[^0-9T]/g, "").slice(0, 15)}-${events.length}.json`;
+        const filePath = path.join(summariesDir, fileName);
+        await fs.writeFile(filePath, `${JSON.stringify(summary, null, 2)}\n`, "utf8");
+        const relativeRef = path.relative(this.sessionDir(sessionId), filePath);
+        await this.updateSession(sessionId, {
+            summaryRefs: [...metadata.summaryRefs, relativeRef],
+        });
+        return summary;
+    }
+    async readLatestSummary(sessionId) {
+        const metadata = await this.readSession(sessionId);
+        const latest = metadata.summaryRefs.at(-1);
+        if (!latest)
+            return undefined;
+        const content = await fs.readFile(path.join(this.sessionDir(sessionId), latest), "utf8");
+        return JSON.parse(content);
+    }
+    async buildResumeBundle(sessionId, options = {}) {
+        const metadata = await this.readSession(sessionId);
+        const transcript = await this.readTranscript(sessionId);
+        const recentCount = Math.max(0, options.recentEvents ?? 20);
+        return {
+            metadata,
+            latestSummary: await this.readLatestSummary(sessionId),
+            recentEvents: recentCount ? transcript.slice(-recentCount) : [],
+        };
+    }
+}

package/dist/vendor/codali/subagents/SubagentOrchestrator.d.ts

@@ -0,0 +1,68 @@
+export type SubagentRole = "explorer" | "reviewer" | "worker" | "verifier" | "custom";
+export type SubagentStatus = "completed" | "failed" | "timed_out";
+export interface SubagentPermissions {
+    readOnly?: boolean;
+    allowedPaths?: string[];
+    writePaths?: string[];
+    allowNetwork?: boolean;
+}
+export interface SubagentSpec {
+    id?: string;
+    role: SubagentRole;
+    goal: string;
+    agentRef?: string;
+    model?: string;
+    tools?: string[];
+    permissions?: SubagentPermissions;
+    maxSteps?: number;
+    maxToolCalls?: number;
+    timeoutMs?: number;
+}
+export interface SubagentResult {
+    id: string;
+    role: SubagentRole;
+    goal: string;
+    status: SubagentStatus;
+    summary: string;
+    output: string;
+    toolCallsExecuted: number;
+    touchedFiles: string[];
+    warnings: string[];
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SubagentRunnerInput {
+    spec: Required<Pick<SubagentSpec, "id" | "role" | "goal">> & SubagentSpec;
+    parentRunId: string;
+}
+export interface SubagentRunnerResult {
+    output: string;
+    toolCallsExecuted?: number;
+    touchedFiles?: string[];
+    warnings?: string[];
+    metadata?: Record<string, unknown>;
+}
+export type SubagentRunner = (input: SubagentRunnerInput) => Promise<SubagentRunnerResult>;
+export interface SubagentOrchestratorOptions {
+    parentRunId: string;
+    maxParallel?: number;
+    maxSubagents?: number;
+    defaultTimeoutMs?: number;
+    runner: SubagentRunner;
+    onEvent?: (event: {
+        type: "subagent_start" | "subagent_result";
+        result?: SubagentResult;
+        spec?: SubagentSpec;
+    }) => void;
+}
+export declare const normalizeSubagentSpec: (spec: SubagentSpec, index: number) => SubagentRunnerInput["spec"];
+export declare const assertNoOverlappingWriteScopes: (specs: SubagentSpec[]) => void;
+export declare class SubagentOrchestrator {
+    private options;
+    constructor(options: SubagentOrchestratorOptions);
+    run(specs: SubagentSpec[]): Promise<SubagentResult[]>;
+}
+//# sourceMappingURL=SubagentOrchestrator.d.ts.map

package/dist/vendor/codali/subagents/SubagentOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubagentOrchestrator.d.ts","sourceRoot":"","sources":["../../src/subagents/SubagentOrchestrator.ts"],"names":[],"mappings":"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"}

package/dist/vendor/codali/subagents/SubagentOrchestrator.js

@@ -0,0 +1,150 @@
+import path from "node:path";
+const normalizeScopePath = (value) => {
+    const normalized = path.posix.normalize(value.replace(/\\/g, "/")).replace(/^\/+/, "");
+    if (!normalized || normalized === ".")
+        return ".";
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`Subagent scope path is outside workspace: ${value}`);
+    }
+    return normalized;
+};
+const scopeContains = (outer, inner) => {
+    if (outer === ".")
+        return true;
+    return inner === outer || inner.startsWith(`${outer}/`);
+};
+const scopesOverlap = (a, b) => scopeContains(a, b) || scopeContains(b, a);
+const stableSpecId = (spec, index) => {
+    if (spec.id?.trim())
+        return spec.id.trim().replace(/[^a-zA-Z0-9._-]+/g, "_");
+    return `${spec.role}-${index + 1}`;
+};
+const summarizeOutput = (output) => {
+    const trimmed = output.trim().replace(/\s+/g, " ");
+    if (!trimmed)
+        return "No output.";
+    return trimmed.length > 240 ? `${trimmed.slice(0, 240)}...` : trimmed;
+};
+const withTimeout = async (promise, timeoutMs) => {
+    if (!timeoutMs || timeoutMs <= 0)
+        return promise;
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("subagent_timeout")), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+};
+export const normalizeSubagentSpec = (spec, index) => {
+    if (!spec.goal.trim())
+        throw new Error("Subagent goal is required");
+    const readOnly = spec.permissions?.readOnly ?? spec.role !== "worker";
+    const allowedPaths = spec.permissions?.allowedPaths?.map(normalizeScopePath);
+    const writePaths = spec.permissions?.writePaths?.map(normalizeScopePath);
+    if (readOnly && writePaths?.length) {
+        throw new Error(`Read-only subagent ${spec.id ?? spec.role} cannot declare write paths`);
+    }
+    return {
+        ...spec,
+        id: stableSpecId(spec, index),
+        role: spec.role,
+        goal: spec.goal.trim(),
+        permissions: {
+            ...spec.permissions,
+            readOnly,
+            allowedPaths,
+            writePaths,
+        },
+    };
+};
+export const assertNoOverlappingWriteScopes = (specs) => {
+    const writers = specs
+        .map((spec, index) => normalizeSubagentSpec(spec, index))
+        .filter((spec) => !spec.permissions?.readOnly && (spec.permissions?.writePaths?.length ?? 0) > 0);
+    for (let left = 0; left < writers.length; left += 1) {
+        for (let right = left + 1; right < writers.length; right += 1) {
+            for (const leftScope of writers[left].permissions?.writePaths ?? []) {
+                for (const rightScope of writers[right].permissions?.writePaths ?? []) {
+                    if (scopesOverlap(leftScope, rightScope)) {
+                        throw new Error(`Subagent write scopes overlap: ${writers[left].id}:${leftScope} and ${writers[right].id}:${rightScope}`);
+                    }
+                }
+            }
+        }
+    }
+};
+export class SubagentOrchestrator {
+    constructor(options) {
+        this.options = options;
+    }
+    async run(specs) {
+        const maxSubagents = Math.max(1, this.options.maxSubagents ?? 8);
+        if (specs.length > maxSubagents) {
+            throw new Error(`Too many subagents requested: ${specs.length} > ${maxSubagents}`);
+        }
+        assertNoOverlappingWriteScopes(specs);
+        const normalized = specs.map(normalizeSubagentSpec);
+        const maxParallel = Math.max(1, this.options.maxParallel ?? 2);
+        const results = new Array(normalized.length);
+        let nextIndex = 0;
+        const runOne = async (index) => {
+            const spec = normalized[index];
+            const started = Date.now();
+            const startedAt = new Date(started).toISOString();
+            this.options.onEvent?.({ type: "subagent_start", spec });
+            try {
+                const runnerResult = await withTimeout(this.options.runner({ spec, parentRunId: this.options.parentRunId }), spec.timeoutMs ?? this.options.defaultTimeoutMs);
+                const ended = Date.now();
+                results[index] = {
+                    id: spec.id,
+                    role: spec.role,
+                    goal: spec.goal,
+                    status: "completed",
+                    summary: summarizeOutput(runnerResult.output),
+                    output: runnerResult.output,
+                    toolCallsExecuted: runnerResult.toolCallsExecuted ?? 0,
+                    touchedFiles: runnerResult.touchedFiles ?? [],
+                    warnings: runnerResult.warnings ?? [],
+                    startedAt,
+                    endedAt: new Date(ended).toISOString(),
+                    durationMs: ended - started,
+                    metadata: runnerResult.metadata,
+                };
+            }
+            catch (error) {
+                const ended = Date.now();
+                const message = error instanceof Error ? error.message : String(error);
+                results[index] = {
+                    id: spec.id,
+                    role: spec.role,
+                    goal: spec.goal,
+                    status: message === "subagent_timeout" ? "timed_out" : "failed",
+                    summary: message,
+                    output: "",
+                    toolCallsExecuted: 0,
+                    touchedFiles: [],
+                    warnings: [],
+                    startedAt,
+                    endedAt: new Date(ended).toISOString(),
+                    durationMs: ended - started,
+                    error: message,
+                };
+            }
+            this.options.onEvent?.({ type: "subagent_result", result: results[index] });
+        };
+        const workers = Array.from({ length: Math.min(maxParallel, normalized.length) }, async () => {
+            while (nextIndex < normalized.length) {
+                const index = nextIndex;
+                nextIndex += 1;
+                await runOne(index);
+            }
+        });
+        await Promise.all(workers);
+        return results;
+    }
+}

package/dist/vendor/codali/tools/ToolRegistry.d.ts

@@ -0,0 +1,9 @@
+import { type ToolContext, type ToolDefinition, type ToolExecutionResult } from "./ToolTypes.js";
+export declare class ToolRegistry {
+    private tools;
+    register(tool: ToolDefinition): void;
+    list(): ToolDefinition[];
+    describe(): Array<Pick<ToolDefinition, "name" | "description" | "inputSchema">>;
+    execute(name: string, args: unknown, context: ToolContext): Promise<ToolExecutionResult>;
+}
+//# sourceMappingURL=ToolRegistry.d.ts.map

package/dist/vendor/codali/tools/ToolRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolRegistry.d.ts","sourceRoot":"","sources":["../../src/tools/ToolRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,cAAc,EAGnB,KAAK,mBAAmB,EAGzB,MAAM,gBAAgB,CAAC;AAyOxB,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAqC;IAElD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAOpC,IAAI,IAAI,cAAc,EAAE;IAIxB,QAAQ,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;IAQzE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAkC/F"}