diffact 0.1.0 → 0.2.0

package/dist/agent-manager.js

@@ -1,502 +0,0 @@
-import { AppServerClient } from "./app-server-client.js";
-import { resolveProjectRoot } from "./project-path.js";
-import { createId } from "./utils.js";
-const getApprovalPolicy = () => process.env.CODEX_APPROVAL_POLICY?.trim() || "on-request";
-const getSandboxMode = () => process.env.CODEX_SANDBOX_MODE?.trim() || "workspace-write";
-const parseTurnId = (params) => {
-    if (!params || typeof params !== "object") {
-        return null;
-    }
-    const record = params;
-    const turn = record.turn;
-    if (turn && typeof turn === "object" && "id" in turn) {
-        const id = turn.id;
-        return typeof id === "string" ? id : null;
-    }
-    if ("turnId" in record) {
-        const id = record.turnId;
-        return typeof id === "string" ? id : null;
-    }
-    return null;
-};
-const parseThreadId = (params) => {
-    if (!params || typeof params !== "object") {
-        return null;
-    }
-    const record = params;
-    if ("threadId" in record) {
-        const id = record.threadId;
-        return typeof id === "string" ? id : null;
-    }
-    const thread = record.thread;
-    if (thread && typeof thread === "object" && "id" in thread) {
-        const id = thread.id;
-        return typeof id === "string" ? id : null;
-    }
-    return null;
-};
-const parseTurnError = (params) => {
-    if (!params || typeof params !== "object") {
-        return null;
-    }
-    const record = params;
-    const error = record.error;
-    if (error && typeof error === "object" && "message" in error) {
-        const message = error.message;
-        return typeof message === "string" ? message : null;
-    }
-    return null;
-};
-const FILTERED_THREAD_CURSOR_PREFIX = "project:";
-const parseThreadListResponse = (value) => {
-    if (!value || typeof value !== "object") {
-        return { data: [], nextCursor: null };
-    }
-    const record = value;
-    const data = Array.isArray(record.data)
-        ? record.data.filter((item) => Boolean(item) && typeof item === "object")
-        : [];
-    const nextCursor = typeof record.nextCursor === "string" ? record.nextCursor : null;
-    return { data, nextCursor };
-};
-const parseThreadListCursor = (cursor) => {
-    if (!cursor || !cursor.startsWith(FILTERED_THREAD_CURSOR_PREFIX)) {
-        return null;
-    }
-    const payload = cursor.slice(FILTERED_THREAD_CURSOR_PREFIX.length);
-    try {
-        const decoded = Buffer.from(payload, "base64").toString("utf8");
-        const parsed = JSON.parse(decoded);
-        if (!parsed || typeof parsed !== "object") {
-            return null;
-        }
-        const record = parsed;
-        const upstreamCursor = typeof record.upstreamCursor === "string" ? record.upstreamCursor : null;
-        const buffered = Array.isArray(record.buffered)
-            ? record.buffered.filter((item) => Boolean(item) && typeof item === "object")
-            : [];
-        return { upstreamCursor, buffered };
-    }
-    catch {
-        return null;
-    }
-};
-const serializeThreadListCursor = (state) => {
-    const payload = Buffer.from(JSON.stringify(state)).toString("base64");
-    return `${FILTERED_THREAD_CURSOR_PREFIX}${payload}`;
-};
-export class AgentManager {
-    #hub;
-    #agents = new Map();
-    #agentsByThread = new Map();
-    #client;
-    constructor(params) {
-        this.#hub = params.hub;
-        this.#client = new AppServerClient({
-            onNotification: (notification) => {
-                this.#routeNotification(notification);
-            },
-            onRequest: async (request) => this.#handleRequest(request),
-            onClose: (error) => {
-                this.#handleAppServerClose(error);
-            },
-        });
-    }
-    listAgents() {
-        return Array.from(this.#agents.values()).map((agent) => this.#toAgentInfo(agent));
-    }
-    async listThreads(params) {
-        await this.#client.initialize({
-            name: "diffact",
-            title: "diffact",
-            version: "0.1.0",
-        });
-        if (!params.projectPath) {
-            return this.#client.request("thread/list", {
-                cursor: params.cursor ?? null,
-                limit: params.limit ?? null,
-                modelProviders: null,
-            });
-        }
-        const limit = params.limit ?? null;
-        const parsedCursor = parseThreadListCursor(params.cursor ?? null);
-        let upstreamCursor = parsedCursor?.upstreamCursor ?? params.cursor ?? null;
-        const buffered = (parsedCursor?.buffered ?? []).filter((item) => item.cwd === params.projectPath);
-        if (limit !== null && limit <= 0) {
-            return { data: [], nextCursor: null };
-        }
-        if (limit === null) {
-            const response = await this.#client.request("thread/list", {
-                cursor: upstreamCursor,
-                limit: null,
-                modelProviders: null,
-            });
-            const page = parseThreadListResponse(response);
-            return {
-                data: page.data.filter((item) => item.cwd === params.projectPath),
-                nextCursor: page.nextCursor,
-            };
-        }
-        if (buffered.length >= limit) {
-            const remainder = buffered.slice(limit);
-            return {
-                data: buffered.slice(0, limit),
-                nextCursor: remainder.length
-                    ? serializeThreadListCursor({
-                        upstreamCursor,
-                        buffered: remainder,
-                    })
-                    : upstreamCursor,
-            };
-        }
-        const collected = buffered.slice();
-        const seen = new Set();
-        while (true) {
-            const response = await this.#client.request("thread/list", {
-                cursor: upstreamCursor,
-                limit,
-                modelProviders: null,
-            });
-            const page = parseThreadListResponse(response);
-            collected.push(...page.data.filter((item) => item.cwd === params.projectPath));
-            if (collected.length >= limit) {
-                const remainder = collected.slice(limit);
-                return {
-                    data: collected.slice(0, limit),
-                    nextCursor: remainder.length
-                        ? serializeThreadListCursor({
-                            upstreamCursor: page.nextCursor ?? null,
-                            buffered: remainder,
-                        })
-                        : (page.nextCursor ?? null),
-                };
-            }
-            if (!page.nextCursor) {
-                return { data: collected, nextCursor: null };
-            }
-            if (seen.has(page.nextCursor)) {
-                return { data: collected, nextCursor: page.nextCursor };
-            }
-            seen.add(page.nextCursor);
-            upstreamCursor = page.nextCursor;
-        }
-    }
-    getAgent(id) {
-        const agent = this.#agents.get(id);
-        return agent ? this.#toAgentInfo(agent) : null;
-    }
-    async resumeThread(params) {
-        const existing = this.#agentsByThread.get(params.threadId);
-        if (existing) {
-            return this.#toAgentInfo(existing);
-        }
-        const id = createId();
-        const now = new Date().toISOString();
-        const runtime = {
-            id,
-            label: params.label || `thread-${params.threadId.slice(0, 6)}`,
-            status: "completed",
-            createdAt: now,
-            projectPath: params.projectPath,
-            threadId: params.threadId,
-            lastError: undefined,
-            exitCode: null,
-            signal: null,
-            stoppedByUser: false,
-            activeTurnId: null,
-        };
-        this.#agents.set(id, runtime);
-        this.#agentsByThread.set(params.threadId, runtime);
-        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        try {
-            await this.#client.initialize({
-                name: "diffact",
-                title: "diffact",
-                version: "0.1.0",
-            });
-            const threadResponse = await this.#client.request("thread/resume", {
-                threadId: params.threadId,
-            });
-            const threadId = parseThreadId(threadResponse);
-            if (threadId && threadId !== params.threadId) {
-                runtime.threadId = threadId;
-                this.#agentsByThread.set(threadId, runtime);
-            }
-        }
-        catch (error) {
-            runtime.status = "error";
-            runtime.lastError =
-                error instanceof Error ? error.message : "app_server_error";
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-        return this.#toAgentInfo(runtime);
-    }
-    async startAgent(params) {
-        const project = await resolveProjectRoot(params.projectPath);
-        const id = createId();
-        const now = new Date().toISOString();
-        const runtime = {
-            id,
-            label: params.label || `agent-${id.slice(0, 6)}`,
-            status: "starting",
-            createdAt: now,
-            projectPath: project.rootPath,
-            threadId: null,
-            lastError: undefined,
-            exitCode: null,
-            signal: null,
-            stoppedByUser: false,
-            activeTurnId: null,
-        };
-        this.#agents.set(id, runtime);
-        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        try {
-            await this.#client.initialize({
-                name: "diffact",
-                title: "diffact",
-                version: "0.1.0",
-            });
-            const threadResponse = await this.#client.request("thread/start", {
-                model: null,
-                modelProvider: null,
-                cwd: project.rootPath,
-                approvalPolicy: getApprovalPolicy(),
-                sandbox: getSandboxMode(),
-                config: null,
-                baseInstructions: null,
-                developerInstructions: null,
-                experimentalRawEvents: false,
-            });
-            const threadId = parseThreadId(threadResponse);
-            if (!threadId) {
-                throw new Error("app_server_thread_start_failed");
-            }
-            runtime.threadId = threadId;
-            this.#agentsByThread.set(threadId, runtime);
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-            await this.#client.request("turn/start", {
-                threadId: runtime.threadId,
-                input: [{ type: "text", text: params.prompt }],
-                cwd: null,
-                approvalPolicy: null,
-                sandboxPolicy: null,
-                model: null,
-                effort: null,
-                summary: null,
-                outputSchema: null,
-            });
-        }
-        catch (error) {
-            runtime.status = "error";
-            runtime.lastError =
-                error instanceof Error ? error.message : "app_server_error";
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-        return this.#toAgentInfo(runtime);
-    }
-    async startThread(params) {
-        const project = await resolveProjectRoot(params.projectPath);
-        const id = createId();
-        const now = new Date().toISOString();
-        const runtime = {
-            id,
-            label: params.label || `thread-${id.slice(0, 6)}`,
-            status: "starting",
-            createdAt: now,
-            projectPath: project.rootPath,
-            threadId: null,
-            lastError: undefined,
-            exitCode: null,
-            signal: null,
-            stoppedByUser: false,
-            activeTurnId: null,
-        };
-        this.#agents.set(id, runtime);
-        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        try {
-            await this.#client.initialize({
-                name: "diffact",
-                title: "diffact",
-                version: "0.1.0",
-            });
-            const threadResponse = await this.#client.request("thread/start", {
-                model: null,
-                modelProvider: null,
-                cwd: project.rootPath,
-                approvalPolicy: getApprovalPolicy(),
-                sandbox: getSandboxMode(),
-                config: null,
-                baseInstructions: null,
-                developerInstructions: null,
-                experimentalRawEvents: false,
-            });
-            const threadId = parseThreadId(threadResponse);
-            if (!threadId) {
-                throw new Error("app_server_thread_start_failed");
-            }
-            runtime.threadId = threadId;
-            runtime.status = "completed";
-            this.#agentsByThread.set(threadId, runtime);
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-        catch (error) {
-            runtime.status = "error";
-            runtime.lastError =
-                error instanceof Error ? error.message : "app_server_error";
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-        return this.#toAgentInfo(runtime);
-    }
-    stopAgent(id) {
-        const agent = this.#agents.get(id);
-        if (!agent) {
-            return false;
-        }
-        agent.stoppedByUser = true;
-        agent.status = "stopped";
-        if (agent.threadId && agent.activeTurnId) {
-            this.#client
-                .request("turn/interrupt", {
-                threadId: agent.threadId,
-                turnId: agent.activeTurnId,
-            })
-                .catch(() => { });
-        }
-        if (agent.threadId) {
-            this.#agentsByThread.delete(agent.threadId);
-        }
-        this.#hub.send("agent_status", this.#toAgentInfo(agent));
-        return true;
-    }
-    stopThread(threadId) {
-        const runtime = this.#agentsByThread.get(threadId);
-        if (!runtime) {
-            return false;
-        }
-        return this.stopAgent(runtime.id);
-    }
-    async sendMessage(id, message) {
-        const agent = this.#agents.get(id);
-        if (!agent || !agent.threadId) {
-            return false;
-        }
-        agent.status = "running";
-        agent.lastError = undefined;
-        this.#hub.send("agent_status", this.#toAgentInfo(agent));
-        try {
-            await this.#client.initialize({
-                name: "diffact",
-                title: "diffact",
-                version: "0.1.0",
-            });
-            await this.#client.request("turn/start", {
-                threadId: agent.threadId,
-                input: [{ type: "text", text: message }],
-                cwd: null,
-                approvalPolicy: null,
-                sandboxPolicy: null,
-                model: null,
-                effort: null,
-                summary: null,
-                outputSchema: null,
-            });
-        }
-        catch (error) {
-            agent.status = "error";
-            agent.lastError =
-                error instanceof Error ? error.message : "app_server_error";
-            this.#hub.send("agent_status", this.#toAgentInfo(agent));
-        }
-        return true;
-    }
-    #routeNotification(notification) {
-        const threadId = parseThreadId(notification.params);
-        if (threadId) {
-            const runtime = this.#agentsByThread.get(threadId);
-            if (runtime && !runtime.stoppedByUser) {
-                this.#handleNotification(runtime, notification);
-            }
-            return;
-        }
-        for (const runtime of this.#agents.values()) {
-            if (runtime.stoppedByUser) {
-                continue;
-            }
-            this.#handleNotification(runtime, notification);
-        }
-    }
-    #handleNotification(runtime, notification) {
-        let statusChanged = false;
-        if (notification.method === "thread/started") {
-            const threadId = parseThreadId(notification.params);
-            if (threadId) {
-                runtime.threadId = threadId;
-                this.#agentsByThread.set(threadId, runtime);
-                statusChanged = true;
-            }
-        }
-        if (notification.method === "turn/started") {
-            runtime.status = "running";
-            runtime.activeTurnId = parseTurnId(notification.params);
-            statusChanged = true;
-        }
-        if (notification.method === "turn/completed") {
-            runtime.status = "completed";
-            runtime.activeTurnId = null;
-            statusChanged = true;
-        }
-        if (notification.method === "error") {
-            runtime.status = "error";
-            runtime.lastError = parseTurnError(notification.params) || "turn_error";
-            statusChanged = true;
-        }
-        if (statusChanged) {
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-        this.#hub.send("agent_event", {
-            projectPath: runtime.projectPath,
-            threadId: runtime.threadId,
-            event: notification,
-        });
-    }
-    #handleAppServerClose(error) {
-        this.#agentsByThread.clear();
-        for (const runtime of this.#agents.values()) {
-            if (runtime.stoppedByUser) {
-                continue;
-            }
-            runtime.status = "error";
-            runtime.lastError = error?.message || "app_server_closed";
-            runtime.activeTurnId = null;
-            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
-        }
-    }
-    async #handleRequest(request) {
-        if (request.method === "item/commandExecution/requestApproval") {
-            return { decision: "accept" };
-        }
-        if (request.method === "item/fileChange/requestApproval") {
-            return { decision: "accept" };
-        }
-        if (request.method === "applyPatchApproval") {
-            return { decision: "approved" };
-        }
-        if (request.method === "execCommandApproval") {
-            return { decision: "approved" };
-        }
-        return null;
-    }
-    #toAgentInfo(agent) {
-        return {
-            id: agent.id,
-            label: agent.label,
-            status: agent.status,
-            createdAt: agent.createdAt,
-            projectPath: agent.projectPath,
-            threadId: agent.threadId ?? null,
-            lastError: agent.lastError,
-            exitCode: agent.exitCode ?? null,
-            signal: agent.signal ?? null,
-        };
-    }
-}

package/dist/app-server-client.d.ts

@@ -1,38 +0,0 @@
-type RequestId = string | number;
-export type AppServerMessage = {
-    id?: RequestId;
-    method?: string;
-    params?: unknown;
-    result?: unknown;
-    error?: unknown;
-};
-export type AppServerNotification = {
-    method: string;
-    params?: unknown;
-};
-export type AppServerRequest = {
-    id: RequestId;
-    method: string;
-    params?: unknown;
-};
-type AppServerClientOptions = {
-    command?: string;
-    args?: string[];
-    onNotification?: (notification: AppServerNotification) => void;
-    onRequest?: (request: AppServerRequest) => Promise<unknown> | unknown;
-    onClose?: (error?: Error) => void;
-};
-export declare class AppServerClient {
-    #private;
-    constructor(options: AppServerClientOptions);
-    connect(): Promise<void>;
-    initialize(params: {
-        name: string;
-        title?: string;
-        version: string;
-    }): Promise<void>;
-    request(method: string, params?: unknown): Promise<unknown>;
-    notify(method: string, params?: unknown): void;
-    close(): void;
-}
-export {};