bioscode 0.1.5

package/dist/provider/types.d.ts

@@ -0,0 +1,328 @@
+import z from "zod";
+/**
+ * Model capabilities and configuration types
+ */
+export declare const ModelCapabilities: z.ZodObject<{
+    temperature: z.ZodDefault<z.ZodBoolean>;
+    reasoning: z.ZodDefault<z.ZodBoolean>;
+    vision: z.ZodDefault<z.ZodBoolean>;
+    toolUse: z.ZodDefault<z.ZodBoolean>;
+    streaming: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    temperature: boolean;
+    reasoning: boolean;
+    vision: boolean;
+    toolUse: boolean;
+    streaming: boolean;
+}, {
+    temperature?: boolean | undefined;
+    reasoning?: boolean | undefined;
+    vision?: boolean | undefined;
+    toolUse?: boolean | undefined;
+    streaming?: boolean | undefined;
+}>;
+export type ModelCapabilities = z.infer<typeof ModelCapabilities>;
+export declare const ModelCost: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    cacheRead: z.ZodOptional<z.ZodNumber>;
+    cacheWrite: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    input: number;
+    output: number;
+    cacheRead?: number | undefined;
+    cacheWrite?: number | undefined;
+}, {
+    input: number;
+    output: number;
+    cacheRead?: number | undefined;
+    cacheWrite?: number | undefined;
+}>;
+export type ModelCost = z.infer<typeof ModelCost>;
+export declare const ModelLimits: z.ZodObject<{
+    context: z.ZodNumber;
+    output: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    output: number;
+    context: number;
+}, {
+    output: number;
+    context: number;
+}>;
+export type ModelLimits = z.infer<typeof ModelLimits>;
+export declare const ModelInfo: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    family: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodObject<{
+        temperature: z.ZodDefault<z.ZodBoolean>;
+        reasoning: z.ZodDefault<z.ZodBoolean>;
+        vision: z.ZodDefault<z.ZodBoolean>;
+        toolUse: z.ZodDefault<z.ZodBoolean>;
+        streaming: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        temperature: boolean;
+        reasoning: boolean;
+        vision: boolean;
+        toolUse: boolean;
+        streaming: boolean;
+    }, {
+        temperature?: boolean | undefined;
+        reasoning?: boolean | undefined;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+        streaming?: boolean | undefined;
+    }>;
+    cost: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodOptional<z.ZodNumber>;
+        cacheWrite: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    }, {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    }>;
+    limits: z.ZodObject<{
+        context: z.ZodNumber;
+        output: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        output: number;
+        context: number;
+    }, {
+        output: number;
+        context: number;
+    }>;
+    status: z.ZodDefault<z.ZodEnum<["active", "beta", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "beta" | "deprecated";
+    id: string;
+    name: string;
+    provider: string;
+    capabilities: {
+        temperature: boolean;
+        reasoning: boolean;
+        vision: boolean;
+        toolUse: boolean;
+        streaming: boolean;
+    };
+    cost: {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    };
+    limits: {
+        output: number;
+        context: number;
+    };
+    family?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    provider: string;
+    capabilities: {
+        temperature?: boolean | undefined;
+        reasoning?: boolean | undefined;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+        streaming?: boolean | undefined;
+    };
+    cost: {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    };
+    limits: {
+        output: number;
+        context: number;
+    };
+    status?: "active" | "beta" | "deprecated" | undefined;
+    family?: string | undefined;
+}>;
+export type ModelInfo = z.infer<typeof ModelInfo>;
+export declare const ProviderInfo: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    envKeys: z.ZodArray<z.ZodString, "many">;
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        family: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodObject<{
+            temperature: z.ZodDefault<z.ZodBoolean>;
+            reasoning: z.ZodDefault<z.ZodBoolean>;
+            vision: z.ZodDefault<z.ZodBoolean>;
+            toolUse: z.ZodDefault<z.ZodBoolean>;
+            streaming: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        }, {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        }>;
+        cost: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>;
+        limits: z.ZodObject<{
+            context: z.ZodNumber;
+            output: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            output: number;
+            context: number;
+        }, {
+            output: number;
+            context: number;
+        }>;
+        status: z.ZodDefault<z.ZodEnum<["active", "beta", "deprecated"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "beta" | "deprecated";
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        family?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        status?: "active" | "beta" | "deprecated" | undefined;
+        family?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    envKeys: string[];
+    models: Record<string, {
+        status: "active" | "beta" | "deprecated";
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            vision: boolean;
+            toolUse: boolean;
+            streaming: boolean;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        family?: string | undefined;
+    }>;
+}, {
+    id: string;
+    name: string;
+    envKeys: string[];
+    models: Record<string, {
+        id: string;
+        name: string;
+        provider: string;
+        capabilities: {
+            temperature?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            vision?: boolean | undefined;
+            toolUse?: boolean | undefined;
+            streaming?: boolean | undefined;
+        };
+        cost: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        };
+        limits: {
+            output: number;
+            context: number;
+        };
+        status?: "active" | "beta" | "deprecated" | undefined;
+        family?: string | undefined;
+    }>;
+}>;
+export type ProviderInfo = z.infer<typeof ProviderInfo>;
+/**
+ * Provider configuration from user config
+ */
+export declare const ProviderConfig: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, any> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}, {
+    options?: Record<string, any> | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}>;
+export type ProviderConfig = z.infer<typeof ProviderConfig>;

package/dist/server/index.d.ts

@@ -0,0 +1,21 @@
+export interface ServerInfo {
+    port: number;
+    projectDir: string;
+    startedAt: number;
+}
+/**
+ * Start the HTTP server
+ */
+export declare function startServer(port?: number): Promise<ServerInfo>;
+/**
+ * Stop the HTTP server
+ */
+export declare function stopServer(): void;
+/**
+ * Get current server info
+ */
+export declare function getServerInfo(): ServerInfo | null;
+/**
+ * Get the SSE emitter for broadcasting events
+ */
+export { SSEEmitter } from "./sse/emitter";

package/dist/server/routes/api.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const apiRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/routes/auth.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const authRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/routes/events.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const eventsRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/routes/health.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const healthRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/routes/sessions.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const sessionsRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/services/agent.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Agent Service
+ *
+ * Handles LLM invocation and streaming for the HTTP API.
+ * Extracted from TUI REPL for reuse.
+ */
+export type AgentMode = "ask" | "auto" | "plan";
+export declare namespace AgentService {
+    interface ImageAttachment {
+        data: string;
+        mimeType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+        filename?: string;
+    }
+    interface RunOptions {
+        sessionId: string;
+        content: string;
+        requestId: string;
+        images?: ImageAttachment[];
+        mode?: AgentMode;
+    }
+    /**
+     * Run the agent for a prompt
+     */
+    function run(options: RunOptions): Promise<void>;
+    /**
+     * Cancel an active generation
+     */
+    function cancel(sessionId: string): boolean;
+    /**
+     * Optimize context for a session by generating a summary
+     */
+    function optimizeContext(options: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<void>;
+    /**
+     * Cancel an active context optimization
+     */
+    function cancelOptimization(sessionId: string): boolean;
+}

package/dist/server/services/permission.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Permission Service
+ *
+ * Manages permission requests for tool execution in "ask" mode.
+ * Tools wait for user approval before executing.
+ */
+export type PermissionResponse = "allow" | "allow_always" | "deny" | "deny_with_message";
+export interface PermissionRequest {
+    id: string;
+    sessionId: string;
+    requestId: string;
+    toolName: string;
+    toolCallId: string;
+    args: Record<string, unknown>;
+    description?: string;
+    createdAt: number;
+}
+export declare namespace PermissionService {
+    /**
+     * Request permission for a tool execution
+     * Returns a promise that resolves when the user responds
+     */
+    function request(sessionId: string, requestId: string, toolName: string, toolCallId: string, args: Record<string, unknown>, description?: string): Promise<{
+        allowed: boolean;
+        message?: string;
+    }>;
+    /**
+     * Respond to a pending permission request
+     */
+    function respond(permissionId: string, response: PermissionResponse, message?: string): boolean;
+    /**
+     * Cancel a pending permission request
+     */
+    function cancel(permissionId: string): boolean;
+    /**
+     * Cancel all pending permissions for a session
+     */
+    function cancelSession(sessionId: string): number;
+    /**
+     * Get all pending permissions for a session
+     */
+    function getPending(sessionId: string): PermissionRequest[];
+}

package/dist/server/sse/emitter.d.ts

@@ -0,0 +1,57 @@
+export interface SSEClient {
+    id: string;
+    controller: ReadableStreamDefaultController<Uint8Array>;
+    connectedAt: number;
+}
+export interface SSEEvent {
+    type: string;
+    data: unknown;
+    id?: string;
+}
+declare class SSEEmitterClass {
+    private clients;
+    private heartbeatInterval;
+    private encoder;
+    /**
+     * Start heartbeat to keep connections alive
+     */
+    startHeartbeat(intervalMs?: number): void;
+    /**
+     * Stop heartbeat
+     */
+    stopHeartbeat(): void;
+    /**
+     * Add a new SSE client
+     */
+    addClient(id: string, controller: ReadableStreamDefaultController<Uint8Array>): void;
+    /**
+     * Remove an SSE client
+     */
+    removeClient(id: string): void;
+    /**
+     * Send event to a specific client
+     */
+    sendToClient(clientId: string, event: SSEEvent): void;
+    /**
+     * Broadcast event to all connected clients
+     */
+    broadcast(event: SSEEvent): void;
+    /**
+     * Format event for SSE protocol
+     */
+    private formatSSE;
+    /**
+     * Get connected client count
+     */
+    get clientCount(): number;
+    /**
+     * Get all client IDs
+     */
+    getClientIds(): string[];
+    /**
+     * Reset emitter state (for testing)
+     */
+    reset(): void;
+}
+export declare const SSEEmitter: SSEEmitterClass;
+export {};

package/dist/session/context-cache.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Context Memoization Cache
+ *
+ * Caches frequently-accessed context information to reduce redundant tool calls:
+ * - Git status
+ * - README contents
+ * - Directory structure
+ *
+ * Cache is cleared when:
+ * - /optimize command is executed
+ * - Session is restarted
+ * - Manual invalidation
+ */
+export interface CachedContext {
+    gitStatus?: {
+        output: string;
+        timestamp: number;
+    };
+    readme?: {
+        content: string;
+        path: string;
+        timestamp: number;
+    };
+    dirStructure?: {
+        output: string;
+        depth: number;
+        timestamp: number;
+    };
+}
+/**
+ * Context Cache - Memoizes expensive context operations
+ */
+export declare class ContextCache {
+    private static cache;
+    private static sessionCaches;
+    /**
+     * Get cached value for a session
+     */
+    static get<T>(sessionId: string, key: string): T | undefined;
+    /**
+     * Set cached value for a session
+     */
+    static set<T>(sessionId: string, key: string, value: T): void;
+    /**
+     * Check if key exists in cache
+     */
+    static has(sessionId: string, key: string): boolean;
+    /**
+     * Clear cache for specific session
+     */
+    static clearSession(sessionId: string): void;
+    /**
+     * Clear specific key for session
+     */
+    static clearKey(sessionId: string, key: string): void;
+    /**
+     * Clear all caches
+     */
+    static clearAll(): void;
+    /**
+     * Get cache statistics
+     */
+    static stats(): {
+        sessions: number;
+        totalEntries: number;
+    };
+}
+/**
+ * Cache keys for common context operations
+ */
+export declare const CacheKeys: {
+    readonly GIT_STATUS: "git:status";
+    readonly README: "readme:content";
+    readonly DIR_STRUCTURE: "dir:structure";
+};