jukto-cli 0.1.0

package/dist/ai/index.d.ts

@@ -0,0 +1,57 @@
+import type { AiEvent, ModelSelector, FileAttachment, CodexPromptOptions } from "./interface.js";
+export type AiBackend = "opencode" | "codex";
+export declare class AiManager {
+    private _providers;
+    private _available;
+    init(): Promise<void>;
+    private tryInit;
+    availableBackends(): AiBackend[];
+    private get;
+    subscribe(emitter: (backend: AiBackend, event: AiEvent) => void): () => void;
+    destroy(): Promise<void>;
+    listAllSessions(): Promise<{
+        sessions: Array<Record<string, unknown> & {
+            backend: AiBackend;
+        }>;
+    }>;
+    createSession(backend: AiBackend, title?: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
+    getSession(backend: AiBackend, id: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
+    deleteSession(backend: AiBackend, id: string): Promise<{
+        deleted: boolean;
+    }>;
+    renameSession(backend: AiBackend, id: string, title: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
+    getMessages(backend: AiBackend, sessionId: string): Promise<{
+        messages: import("./interface.js").MessageInfo[];
+    }>;
+    statuses(backend: AiBackend): Promise<{
+        statuses: Record<string, unknown>;
+    }>;
+    prompt(backend: AiBackend, sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
+        ack: true;
+    }>;
+    abort(backend: AiBackend, sessionId: string): Promise<Record<string, never>>;
+    agents(backend?: AiBackend): Promise<{
+        agents: unknown;
+    }>;
+    providers(backend?: AiBackend): Promise<import("./interface.js").ProviderInfo>;
+    setAuth(backend: AiBackend, providerId: string, key: string): Promise<Record<string, never>>;
+    command(backend: AiBackend, sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(backend: AiBackend, sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(backend: AiBackend, sessionId: string): Promise<Record<string, never>>;
+    share(backend: AiBackend, sessionId: string): Promise<{
+        share: import("./interface.js").ShareInfo;
+    }>;
+    permissionReply(backend: AiBackend, sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply(backend: AiBackend, sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject(backend: AiBackend, sessionId: string, questionId: string): Promise<Record<string, never>>;
+}
+export declare function createAiManager(): Promise<AiManager>;
+export type { AIProvider, AiEventEmitter, AiEvent, ModelSelector } from "./interface.js";

package/dist/ai/index.js

@@ -0,0 +1,119 @@
+// AI manager — runs both OpenCode and Codex simultaneously and routes calls
+// by the `backend` field in each request. Backends that fail to init are
+// skipped gracefully; the available list is exposed to the app.
+const DEBUG_MODE = process.env.JUKTO_DEBUG === "1" || process.env.JUKTO_DEBUG_AI === "1";
+export class AiManager {
+    _providers = {};
+    _available = [];
+    async init() {
+        await Promise.allSettled([
+            this.tryInit("opencode"),
+            this.tryInit("codex"),
+        ]);
+        if (this._available.length === 0) {
+            console.warn("[ai] No AI backends available. CLI will continue without AI features.");
+            return;
+        }
+        if (DEBUG_MODE) {
+            console.log(`[ai] Available backends: ${this._available.join(", ")}`);
+        }
+    }
+    async tryInit(backend) {
+        try {
+            if (backend === "opencode") {
+                const { OpenCodeProvider } = await import("./opencode.js");
+                const p = new OpenCodeProvider();
+                await p.init();
+                this._providers.opencode = p;
+            }
+            else {
+                const { CodexProvider } = await import("./codex.js");
+                const p = new CodexProvider();
+                await p.init();
+                this._providers.codex = p;
+            }
+            this._available.push(backend);
+        }
+        catch (err) {
+            if (DEBUG_MODE) {
+                console.warn(`[ai] ${backend} backend unavailable: ${err.message}`);
+            }
+        }
+    }
+    availableBackends() {
+        return [...this._available];
+    }
+    get(backend) {
+        const p = this._providers[backend];
+        if (!p) {
+            throw Object.assign(new Error(`Backend "${backend}" is not available`), { code: "EUNAVAILABLE" });
+        }
+        return p;
+    }
+    // Wire each provider's events to the emitter, tagged with backend name.
+    subscribe(emitter) {
+        const cleanups = this._available.map((backend) => this._providers[backend].subscribe((event) => emitter(backend, event)));
+        return () => cleanups.forEach((c) => c());
+    }
+    async destroy() {
+        await Promise.allSettled(this._available.map((b) => this._providers[b].destroy()));
+    }
+    // List sessions from all available backends, each tagged with its backend.
+    async listAllSessions() {
+        const results = await Promise.allSettled(this._available.map(async (backend) => {
+            const res = await this._providers[backend].listSessions();
+            const sessions = res.sessions ?? [];
+            return sessions.map((s) => ({ ...s, backend }));
+        }));
+        const sessions = results.flatMap((r) => (r.status === "fulfilled" ? r.value : []));
+        return { sessions };
+    }
+    // Session management — all require explicit backend
+    createSession(backend, title) { return this.get(backend).createSession(title); }
+    getSession(backend, id) { return this.get(backend).getSession(id); }
+    deleteSession(backend, id) { return this.get(backend).deleteSession(id); }
+    renameSession(backend, id, title) { return this.get(backend).renameSession(id, title); }
+    getMessages(backend, sessionId) { return this.get(backend).getMessages(sessionId); }
+    async statuses(backend) {
+        const provider = this.get(backend);
+        if (!provider.statuses)
+            return { statuses: {} };
+        return provider.statuses();
+    }
+    prompt(backend, sessionId, text, model, agent, files, codexOptions) {
+        this.get(backend).setActiveSession?.(sessionId);
+        return this.get(backend).prompt(sessionId, text, model, agent, files, codexOptions);
+    }
+    abort(backend, sessionId) { return this.get(backend).abort(sessionId); }
+    // Metadata — backend is optional, falls back to first available
+    agents(backend) { return this.get(backend ?? this._available[0]).agents(); }
+    providers(backend) { return this.get(backend ?? this._available[0]).providers(); }
+    setAuth(backend, providerId, key) { return this.get(backend).setAuth(providerId, key); }
+    // Session operations
+    command(backend, sessionId, command, args) { return this.get(backend).command(sessionId, command, args); }
+    revert(backend, sessionId, messageId) { return this.get(backend).revert(sessionId, messageId); }
+    unrevert(backend, sessionId) { return this.get(backend).unrevert(sessionId); }
+    share(backend, sessionId) { return this.get(backend).share(sessionId); }
+    permissionReply(backend, sessionId, permissionId, response) {
+        return this.get(backend).permissionReply(sessionId, permissionId, response);
+    }
+    questionReply(backend, sessionId, questionId, answers) {
+        const provider = this.get(backend);
+        if (!provider.questionReply) {
+            throw new Error(`Backend "${backend}" does not support question replies`);
+        }
+        return provider.questionReply(sessionId, questionId, answers);
+    }
+    questionReject(backend, sessionId, questionId) {
+        const provider = this.get(backend);
+        if (!provider.questionReject) {
+            throw new Error(`Backend "${backend}" does not support question rejection`);
+        }
+        return provider.questionReject(sessionId, questionId);
+    }
+}
+export async function createAiManager() {
+    const manager = new AiManager();
+    await manager.init();
+    return manager;
+}

package/dist/ai/interface.d.ts

@@ -0,0 +1,93 @@
+export interface AiEvent {
+    type: string;
+    properties: Record<string, unknown>;
+}
+export type AiEventEmitter = (event: AiEvent) => void;
+export interface ModelSelector {
+    providerID: string;
+    modelID: string;
+}
+export interface CodexPromptOptions {
+    reasoningEffort?: string;
+    speed?: string;
+    permissionMode?: "default" | "full-access";
+}
+export interface FileAttachment {
+    type: "file";
+    mime: string;
+    filename?: string;
+    url: string;
+}
+export interface MessageInfo {
+    id: string;
+    role: string;
+    parts: unknown[];
+    time: unknown;
+}
+export interface SessionInfo {
+    [key: string]: unknown;
+}
+export interface ShareInfo {
+    [key: string]: unknown;
+}
+export interface ProviderInfo {
+    providers: unknown[];
+    default: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Every AI backend (OpenCode, Codex, …) implements this interface.
+ * Method names map 1-to-1 with the "ai" namespace actions in index.ts.
+ */
+export interface AIProvider {
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * Register an event emitter. The provider calls it for every async event
+     * (SSE events, streaming tokens, errors, etc.).
+     * Returns a cleanup/unsubscribe function.
+     */
+    subscribe(emitter: AiEventEmitter): () => void;
+    setActiveSession?(sessionId: string): void;
+    createSession(title?: string): Promise<{
+        session: SessionInfo;
+    }>;
+    listSessions(): Promise<{
+        sessions: unknown;
+    }>;
+    getSession(id: string): Promise<{
+        session: SessionInfo;
+    }>;
+    deleteSession(id: string): Promise<{
+        deleted: boolean;
+    }>;
+    renameSession(id: string, title: string): Promise<{
+        session: SessionInfo;
+    }>;
+    getMessages(sessionId: string): Promise<{
+        messages: MessageInfo[];
+    }>;
+    statuses?(): Promise<{
+        statuses: Record<string, unknown>;
+    }>;
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
+        ack: true;
+    }>;
+    abort(sessionId: string): Promise<Record<string, never>>;
+    agents(): Promise<{
+        agents: unknown;
+    }>;
+    providers(): Promise<ProviderInfo>;
+    setAuth(providerId: string, key: string): Promise<Record<string, never>>;
+    command(sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(sessionId: string): Promise<Record<string, never>>;
+    share(sessionId: string): Promise<{
+        share: ShareInfo;
+    }>;
+    permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply?(sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject?(sessionId: string, questionId: string): Promise<Record<string, never>>;
+}

package/dist/ai/interface.js

@@ -0,0 +1,3 @@
+// Shared types for AI provider abstraction.
+// No runtime imports — pure TypeScript types only.
+export {};

package/dist/ai/opencode.d.ts

@@ -0,0 +1,72 @@
+import type { AIProvider, AiEventEmitter, CodexPromptOptions, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+export declare class OpenCodeProvider implements AIProvider {
+    private client;
+    private server;
+    private authHeader;
+    private lastActiveSessionId;
+    private shuttingDown;
+    private emitter;
+    private knownPendingPermissionIds;
+    private knownPendingQuestionIds;
+    private debugLog;
+    private debugWarn;
+    private debugError;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    subscribe(emitter: AiEventEmitter): () => void;
+    setActiveSession(sessionId: string): void;
+    createSession(title?: string): Promise<{
+        session: SessionInfo;
+    }>;
+    listSessions(): Promise<{
+        sessions: unknown;
+    }>;
+    getSession(id: string): Promise<{
+        session: SessionInfo;
+    }>;
+    deleteSession(id: string): Promise<{
+        deleted: boolean;
+    }>;
+    renameSession(id: string, title: string): Promise<{
+        session: SessionInfo;
+    }>;
+    getMessages(sessionId: string): Promise<{
+        messages: MessageInfo[];
+    }>;
+    statuses(): Promise<{
+        statuses: Record<string, unknown>;
+    }>;
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
+        ack: true;
+    }>;
+    abort(sessionId: string): Promise<Record<string, never>>;
+    agents(): Promise<{
+        agents: unknown;
+    }>;
+    providers(): Promise<ProviderInfo>;
+    setAuth(providerId: string, key: string): Promise<Record<string, never>>;
+    command(sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(sessionId: string): Promise<Record<string, never>>;
+    share(sessionId: string): Promise<{
+        share: ShareInfo;
+    }>;
+    permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply(sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject(sessionId: string, questionId: string): Promise<Record<string, never>>;
+    private runSseLoop;
+    private sendPromptAsync;
+    private reconcileOpenCodeState;
+    private refreshBusySessionMessages;
+    private refreshSessionsMetadata;
+    private refreshPendingPermissions;
+    private refreshPendingQuestions;
+    private fetchOpenCodeJson;
+    private refreshSessionStatuses;
+    private fetchSessionStatuses;
+    private trackPermissionEvent;
+    private readString;
+    private asRecord;
+}