bioscode 0.1.5

package/dist/snapshot/index.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare namespace Snapshot {
+    function track(): Promise<string | undefined>;
+    const Patch: z.ZodObject<{
+        hash: z.ZodString;
+        files: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        hash: string;
+        files: string[];
+    }, {
+        hash: string;
+        files: string[];
+    }>;
+    type Patch = z.infer<typeof Patch>;
+    function patch(hash: string): Promise<Patch>;
+    function restore(snapshot: string): Promise<void>;
+    function revert(patches: Patch[]): Promise<void>;
+    function diff(hash: string): Promise<string>;
+    const FileDiff: z.ZodObject<{
+        file: z.ZodString;
+        before: z.ZodString;
+        after: z.ZodString;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        before: string;
+        after: string;
+        additions: number;
+        deletions: number;
+    }, {
+        file: string;
+        before: string;
+        after: string;
+        additions: number;
+        deletions: number;
+    }>;
+    type FileDiff = z.infer<typeof FileDiff>;
+    function diffFull(from: string, to: string): Promise<FileDiff[]>;
+}

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export { Storage } from "./storage";

package/dist/storage/storage.d.ts

@@ -0,0 +1,34 @@
+export declare namespace Storage {
+    /**
+     * Write data to storage
+     */
+    function write<T>(key: string[], data: T): Promise<void>;
+    /**
+     * Read data from storage
+     */
+    function read<T>(key: string[]): Promise<T | undefined>;
+    /**
+     * Update data in storage using an editor function
+     */
+    function update<T>(key: string[], editor: (data: T) => void): Promise<T>;
+    /**
+     * Check if a key exists
+     */
+    function exists(key: string[]): Promise<boolean>;
+    /**
+     * Remove data from storage
+     */
+    function remove(key: string[]): Promise<void>;
+    /**
+     * List all keys under a prefix
+     */
+    function list(prefix: string[]): Promise<string[][]>;
+    /**
+     * List subdirectories under a prefix
+     */
+    function listDirs(prefix: string[]): Promise<string[]>;
+    /**
+     * Clear all data under a prefix
+     */
+    function clear(prefix: string[]): Promise<void>;
+}

package/dist/theme.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Theme & Brand Configuration
+ *
+ * This file contains all branding and theming configuration for the application.
+ * To customize the brand/theme, modify the values in this file directly.
+ *
+ * For a complete rebrand, you'll also need to update:
+ * - package.json: Change the "bin" field to match your command name
+ */
+/** Product display name shown in UI and messages */
+export declare const PRODUCT_NAME = "Bioscode";
+/** CLI command name (lowercase, alphanumeric with hyphens) */
+export declare const PRODUCT_COMMAND = "bioscode";
+/** Configuration directory name (hidden folder in project/home) */
+export declare const CONFIG_DIR = ".bioscode";
+/** Configuration file name */
+export declare const CONFIG_FILE = "bioscode.jsonc";
+/** Rules/instructions file name */
+export declare const RULES_FILE = "BIOSCODE.md";
+/** Environment variable prefix */
+export declare const ENV_PREFIX = "BIOSCODE_";
+/** Simple logo for compact spaces (e.g., welcome screen) */
+export declare const LOGO_SIMPLE: string[];
+/** Extended logo for larger displays (e.g., CLI mode) */
+export declare const LOGO_EXTENDED: string[];
+/** ASCII-only logo (fallback for terminals without UTF-8 support) */
+export declare const LOGO_ASCII: string[];
+/** Local rule files searched in project directories */
+export declare const LOCAL_RULE_FILES: readonly ["BIOSCODE.md", "AGENTS.md", "CONTEXT.md"];
+/** Global rule files searched in home directory */
+export declare const GLOBAL_RULE_FILES: readonly ["BIOSCODE.md"];
+/** Default theme name */
+export declare const DEFAULT_THEME = "bios";
+/** Primary brand color (used for logo, highlights, etc.) */
+export declare const PRIMARY_COLOR = "#01b02aff";
+/** Theme interface definition */
+export interface Theme {
+    name: string;
+    background: string;
+    foreground: string;
+    text: string;
+    primary: string;
+    secondary: string;
+    success: string;
+    warning: string;
+    error: string;
+    muted: string;
+    border: string;
+    selection: string;
+    diffAdd: string;
+    diffRemove: string;
+    diffContext: string;
+    diffHunkHeader: string;
+}
+/** Available themes */
+export declare const themes: Record<string, Theme>;
+/** Get the current active theme */
+export declare function getTheme(): Theme;
+/** Set the active theme by name */
+export declare function setTheme(name: string): void;
+/** Get all available theme names */
+export declare function getThemeNames(): string[];
+/** Initialize theme (can be called at startup) */
+export declare function initTheme(themeName?: string): void;

package/dist/tool/bash.d.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const BashTool: Tool.Info<z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    workdir: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    timeout?: number | undefined;
+    workdir?: string | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    workdir?: string | undefined;
+}>, {
+    exitCode: number;
+    preview: string;
+    error: string | undefined;
+}>;

package/dist/tool/edit.d.ts

@@ -0,0 +1,21 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const EditTool: Tool.Info<z.ZodObject<{
+    filePath: z.ZodString;
+    oldString: z.ZodString;
+    newString: z.ZodString;
+    replaceAll: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    replaceAll: boolean;
+    filePath: string;
+    oldString: string;
+    newString: string;
+}, {
+    filePath: string;
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean | undefined;
+}>, {
+    action: string;
+    replacements: number;
+}>;

package/dist/tool/glob.d.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const GlobTool: Tool.Info<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    path?: string | undefined;
+}, {
+    pattern: string;
+    path?: string | undefined;
+}>, {
+    count: number;
+    truncated: boolean;
+}>;

package/dist/tool/grep.d.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const GrepTool: Tool.Info<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    output_mode: z.ZodOptional<z.ZodEnum<["content", "files_with_matches", "count"]>>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    path?: string | undefined;
+    glob?: string | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    glob?: string | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
+}>, {
+    count: number;
+}>;

package/dist/tool/image.d.ts

@@ -0,0 +1,22 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const ImageTool: Tool.Info<z.ZodObject<{
+    prompt: z.ZodString;
+    filename: z.ZodString;
+    directory: z.ZodOptional<z.ZodString>;
+    aspectRatio: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "9:16", "4:3", "3:4"]>>;
+}, "strip", z.ZodTypeAny, {
+    filename: string;
+    prompt: string;
+    directory?: string | undefined;
+    aspectRatio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
+}, {
+    filename: string;
+    prompt: string;
+    directory?: string | undefined;
+    aspectRatio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
+}>, {
+    path: string;
+    size: number;
+    duration: string;
+}>;

package/dist/tool/index.d.ts

@@ -0,0 +1,11 @@
+export { Tool } from "./tool";
+export { ToolRegistry } from "./registry";
+export { ReadTool } from "./read";
+export { GlobTool } from "./glob";
+export { GrepTool } from "./grep";
+export { BashTool } from "./bash";
+export { WriteTool } from "./write";
+export { EditTool } from "./edit";
+export { LsTool } from "./ls";
+export { TodoTool, TodoEvent, getTodos, clearTodos, type TodoItem } from "./todo";
+export { ImageTool } from "./image";

package/dist/tool/ls.d.ts

@@ -0,0 +1,14 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const LsTool: Tool.Info<z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    depth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+    depth?: number | undefined;
+}, {
+    path?: string | undefined;
+    depth?: number | undefined;
+}>, {
+    count: number;
+}>;

package/dist/tool/read.d.ts

@@ -0,0 +1,17 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const ReadTool: Tool.Info<z.ZodObject<{
+    filePath: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}, {
+    filePath: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}>, {
+    preview: string;
+}>;

package/dist/tool/registry.d.ts

@@ -0,0 +1,30 @@
+import { Tool } from "./tool";
+export declare namespace ToolRegistry {
+    /**
+     * Get all registered tools
+     */
+    function all(): readonly Tool.Info<any, any>[];
+    /**
+     * Get a tool by its ID
+     */
+    function get(id: string): Tool.Info<any, any> | undefined;
+    /**
+     * Check if a tool exists
+     */
+    function has(id: string): boolean;
+    /**
+     * Get all tool IDs
+     */
+    function ids(): string[];
+    /**
+     * Initialize all tools and return their definitions
+     * This is used when setting up the LLM with available tools
+     * Conditional tools that return null during init are skipped
+     */
+    function initialize(ctx?: Tool.InitContext): Promise<Tool.Initialized[]>;
+    /**
+     * Initialize a specific subset of tools
+     * Conditional tools that return null during init are skipped
+     */
+    function initializeSubset(ids: string[], ctx?: Tool.InitContext): Promise<Tool.Initialized[]>;
+}

package/dist/tool/think.d.ts

@@ -0,0 +1,11 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const ThinkTool: Tool.Info<z.ZodObject<{
+    thought: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+}, {
+    thought: string;
+}>, {
+    thoughtLength: number;
+}>;

package/dist/tool/todo.d.ts

@@ -0,0 +1,76 @@
+import z from "zod";
+import { Tool } from "./tool";
+/**
+ * Todo Tool
+ *
+ * Allows the agent to create and manage a task list for tracking progress.
+ * Tasks are displayed in the UI and help users understand what the agent is doing.
+ */
+export interface TodoItem {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    activeForm: string;
+}
+export declare const TodoEvent: {
+    Updated: {
+        type: "todo.updated";
+        properties: z.ZodObject<{
+            todos: z.ZodArray<z.ZodObject<{
+                content: z.ZodString;
+                status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+                activeForm: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                status: "completed" | "pending" | "in_progress";
+                content: string;
+                activeForm: string;
+            }, {
+                status: "completed" | "pending" | "in_progress";
+                content: string;
+                activeForm: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            todos: {
+                status: "completed" | "pending" | "in_progress";
+                content: string;
+                activeForm: string;
+            }[];
+        }, {
+            todos: {
+                status: "completed" | "pending" | "in_progress";
+                content: string;
+                activeForm: string;
+            }[];
+        }>;
+    };
+};
+export declare function getTodos(sessionId: string): TodoItem[];
+export declare function clearTodos(sessionId: string): void;
+export declare const TodoTool: Tool.Info<z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+        activeForm: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "completed" | "pending" | "in_progress";
+        content: string;
+        activeForm: string;
+    }, {
+        status: "completed" | "pending" | "in_progress";
+        content: string;
+        activeForm: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    todos: {
+        status: "completed" | "pending" | "in_progress";
+        content: string;
+        activeForm: string;
+    }[];
+}, {
+    todos: {
+        status: "completed" | "pending" | "in_progress";
+        content: string;
+        activeForm: string;
+    }[];
+}>, {
+    todosCount: number;
+}>;

package/dist/tool/tool.d.ts

@@ -0,0 +1,65 @@
+import z from "zod";
+export declare namespace Tool {
+    interface Metadata {
+        [key: string]: any;
+    }
+    export interface InitContext {
+        agent?: any;
+    }
+    export type Context<M extends Metadata = Metadata> = {
+        sessionID: string;
+        messageID: string;
+        agent: string;
+        abort: AbortSignal;
+        callID?: string;
+        extra?: {
+            [key: string]: any;
+        };
+        metadata(input: {
+            title?: string;
+            metadata?: M;
+        }): void;
+    };
+    export interface FilePart {
+        id: string;
+        sessionID: string;
+        messageID: string;
+        type: "file";
+        mime: string;
+        url: string;
+    }
+    export interface ToolDefinition<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
+        description: string;
+        parameters: Parameters;
+        execute(args: z.infer<Parameters>, ctx: Context): Promise<{
+            title: string;
+            metadata: M;
+            output: string;
+            attachments?: FilePart[];
+        }>;
+        formatValidationError?(error: z.ZodError): string;
+    }
+    export interface Info<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
+        id: string;
+        init: (ctx?: InitContext) => Promise<ToolDefinition<Parameters, M> | null>;
+    }
+    export type InferParameters<T extends Info> = T extends Info<infer P> ? z.infer<P> : never;
+    export type InferMetadata<T extends Info> = T extends Info<any, infer M> ? M : never;
+    /**
+     * Represents an initialized tool ready for use
+     */
+    export interface Initialized<P extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
+        id: string;
+        description: string;
+        parameters: P;
+        execute(args: z.infer<P>, ctx: Context): Promise<{
+            title: string;
+            metadata: M;
+            output: string;
+            attachments?: FilePart[];
+        }>;
+        formatValidationError?(error: z.ZodError): string;
+    }
+    export function define<Parameters extends z.ZodType, Result extends Metadata>(id: string, init: Info<Parameters, Result>["init"] | ToolDefinition<Parameters, Result> | null): Info<Parameters, Result>;
+    export {};
+}

package/dist/tool/webfetch.d.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const WebFetchTool: Tool.Info<z.ZodObject<{
+    url: z.ZodString;
+    selector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    selector?: string | undefined;
+}, {
+    url: string;
+    selector?: string | undefined;
+}>, {
+    url: string;
+    length: number;
+}>;

package/dist/tool/write.d.ts

@@ -0,0 +1,16 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const WriteTool: Tool.Info<z.ZodObject<{
+    filePath: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    filePath: string;
+}, {
+    content: string;
+    filePath: string;
+}>, {
+    action: string;
+    lines: number;
+    preview: string;
+}>;

package/dist/tui/App.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Main TUI Application Component
+ *
+ * Root React component that manages routing and global state.
+ */
+import type { TuiOptions } from "./index";
+interface AppProps extends TuiOptions {
+}
+export declare function App({ sessionId: initialSessionId, onExit, instanceContext }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui/components/Header.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Header Component
+ *
+ * Displays the app title, mode indicator, and session title.
+ */
+import React from "react";
+type Mode = "auto" | "plan" | "ask";
+interface HeaderProps {
+    title?: string;
+    mode: Mode;
+}
+export declare const Header: React.NamedExoticComponent<HeaderProps>;
+export {};

package/dist/tui/components/LoadingIndicator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LoadingIndicator Component
+ *
+ * Isolated loading spinner with local animation state to prevent parent re-renders.
+ * CRITICAL: Animation loop is self-contained - does NOT cause parent (REPL) to re-render.
+ */
+import React from "react";
+interface LoadingIndicatorProps {
+    baseActivity: string;
+    tokenUsage: {
+        input: number;
+        output: number;
+    };
+    escapePressed: boolean;
+}
+/**
+ * LoadingIndicator with optimized animation
+ *
+ * CRITICAL ARCHITECTURE for flicker-free animation:
+ * - Local state for spinner frame, isolated from parent re-renders
+ * - Fixed-width layout to prevent text reflow
+ * - React.memo with custom comparison to prevent parent-triggered re-renders
+ * - Low frequency updates (8fps) to minimize layout recalculations
+ */
+export declare const LoadingIndicator: React.NamedExoticComponent<LoadingIndicatorProps>;
+export {};

package/dist/tui/components/Message/AssistantMessage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AssistantMessage Component
+ *
+ * Displays an assistant message with markdown rendering.
+ */
+import React from "react";
+interface AssistantMessageProps {
+    content: string;
+}
+export declare const AssistantMessage: React.NamedExoticComponent<AssistantMessageProps>;
+export {};

package/dist/tui/components/Message/ReasoningMessage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ReasoningMessage Component
+ *
+ * Displays agent reasoning/thinking in a compact format.
+ */
+import React from "react";
+interface ReasoningMessageProps {
+    content: string;
+    label?: string;
+    streaming?: boolean;
+    termWidth?: number;
+}
+export declare const ReasoningMessage: React.NamedExoticComponent<ReasoningMessageProps>;
+/**
+ * Compact version for message history
+ */
+export declare function ReasoningHistoryMessage({ content, termWidth: termWidthProp }: {
+    content: string;
+    termWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui/components/Message/ToolCallMessage.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ToolCallMessage Component
+ *
+ * Displays a tool call with IN/OUT format.
+ * For edit/write tools, shows a compact diff preview.
+ */
+import React from "react";
+type ToolStatus = "pending" | "running" | "completed" | "failed";
+interface ToolCallMessageProps {
+    name: string;
+    args?: Record<string, any>;
+    status: ToolStatus;
+    output?: string;
+    termWidth?: number;
+}
+export declare const ToolCallMessage: React.NamedExoticComponent<ToolCallMessageProps>;
+/**
+ * Compact version for message history (tool results)
+ */
+export declare const ToolResultMessage: React.NamedExoticComponent<{
+    toolName?: string;
+    input?: Record<string, any>;
+    output?: string;
+    termWidth?: number;
+}>;
+export {};

package/dist/tui/components/Message/UserMessage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * UserMessage Component
+ *
+ * Displays a user message in the conversation.
+ * Long messages are truncated to 3 lines with a count indicator.
+ */
+import React from "react";
+interface UserMessageProps {
+    content: string;
+}
+export declare const UserMessage: React.NamedExoticComponent<UserMessageProps>;
+export {};

package/dist/tui/components/Message/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Message Component
+ *
+ * Dispatcher that renders the appropriate message component based on type.
+ */
+import React from "react";
+import type { MessageWithParts } from "../../../session/types";
+interface MessageProps {
+    message: MessageWithParts;
+    termWidth?: number;
+    maxToolResults?: number;
+}
+export declare const Message: React.NamedExoticComponent<MessageProps>;
+export { UserMessage } from "./UserMessage";
+export { AssistantMessage } from "./AssistantMessage";
+export { ToolCallMessage, ToolResultMessage } from "./ToolCallMessage";

package/dist/tui/components/PermissionPrompt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PermissionPrompt Component
+ *
+ * Displays permission requests and handles user responses.
+ */
+export declare function PermissionPrompt(): import("react/jsx-runtime").JSX.Element | null;