bioscode 0.1.5

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./config";
+export * from "./markdown";

package/dist/config/markdown.d.ts

@@ -0,0 +1,415 @@
+import matter from "gray-matter";
+import { z } from "zod";
+export declare namespace ConfigMarkdown {
+    const FILE_REGEX: RegExp;
+    const SHELL_REGEX: RegExp;
+    function files(template: string): RegExpExecArray[];
+    function shell(template: string): RegExpExecArray[];
+    function parse(filePath: string): Promise<matter.GrayMatterFile<string>>;
+    const FrontmatterError: {
+        new (data: {
+            path: string;
+            message: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ConfigFrontmatterError";
+            readonly data: {
+                path: string;
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ConfigFrontmatterError">;
+                data: z.ZodObject<{
+                    path: z.ZodString;
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    message: string;
+                }, {
+                    path: string;
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            }, {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            }>;
+            toObject(): {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ConfigFrontmatterError">;
+            data: z.ZodObject<{
+                path: z.ZodString;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                message: string;
+            }, {
+                path: string;
+                message: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "ConfigFrontmatterError";
+            data: {
+                path: string;
+                message: string;
+            };
+        }, {
+            name: "ConfigFrontmatterError";
+            data: {
+                path: string;
+                message: string;
+            };
+        }>;
+        isInstance(input: any): input is {
+            readonly name: "ConfigFrontmatterError";
+            readonly data: {
+                path: string;
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ConfigFrontmatterError">;
+                data: z.ZodObject<{
+                    path: z.ZodString;
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    message: string;
+                }, {
+                    path: string;
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            }, {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            }>;
+            toObject(): {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                toObject(): {
+                    name: Name;
+                    data: z.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                }, {
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                    toObject(): {
+                        name: Name;
+                        data: z.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                isInstance(input: any): input is InstanceType</*elided*/ any>;
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: /*elided*/ any;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}

package/dist/constants/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Constants Module
+ * Re-exports from theme module for backward compatibility
+ */
+export { VERSION } from "./version";
+export { PRODUCT_NAME, PRODUCT_COMMAND, CONFIG_DIR, CONFIG_FILE, RULES_FILE, ENV_PREFIX, LOCAL_RULE_FILES, GLOBAL_RULE_FILES, } from "../theme";

package/dist/constants/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Version constant
+ * Separated from brand constants to avoid circular dependencies
+ */
+export declare const VERSION = "0.1.5";

package/dist/diff/engine.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diff Engine
+ *
+ * Motor de diff para PorterCode.
+ * Implementacion propia basada en el algoritmo de longest common subsequence.
+ */
+import type { DiffResult, DiffOptions, WordChange } from "./types";
+/**
+ * Computa el diff entre dos contenidos
+ */
+export declare function computeDiff(oldContent: string, newContent: string, options: DiffOptions): DiffResult;
+/**
+ * Computa cambios word-level entre dos lineas
+ */
+export declare function computeWordDiff(oldLine: string, newLine: string): WordChange[];

package/dist/diff/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Diff Module
+ *
+ * Sistema de diff propio para PorterCode.
+ * Usa algoritmo LCS (Longest Common Subsequence) para generar diffs.
+ */
+export { computeDiff, computeWordDiff } from "./engine";
+export type { DiffResult, DiffHunk, DiffLine, DiffOptions, WordChange, ChangeType, } from "./types";

package/dist/diff/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Diff Types
+ *
+ * Estructuras de datos propias para el sistema de diff de PorterCode.
+ * Usa Patience algorithm para generar diffs mas legibles.
+ */
+/**
+ * Tipos de cambio en una linea
+ */
+export type ChangeType = "add" | "remove" | "context" | "modify";
+/**
+ * Cambio a nivel de palabra dentro de una linea
+ */
+export interface WordChange {
+    text: string;
+    type: "added" | "removed" | "unchanged";
+}
+/**
+ * Una linea individual en el diff
+ */
+export interface DiffLine {
+    type: ChangeType;
+    content: string;
+    lineNumber: {
+        old?: number;
+        new?: number;
+    };
+    /** Cambios word-level para lineas modificadas */
+    wordChanges?: WordChange[];
+}
+/**
+ * Un hunk con contexto y metadatos
+ */
+export interface DiffHunk {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: DiffLine[];
+    /** Encabezado de funcion/clase si es detectado */
+    header?: string;
+}
+/**
+ * Resultado completo del diff
+ */
+export interface DiffResult {
+    filePath: string;
+    hunks: DiffHunk[];
+    stats: {
+        additions: number;
+        deletions: number;
+    };
+}
+/**
+ * Opciones de configuracion para el diff
+ */
+export interface DiffOptions {
+    /** Ruta del archivo (requerido) */
+    filePath: string;
+    /** Lineas de contexto antes/despues de cambios (default: 3) */
+    context?: number;
+    /** Habilitar diff word-level (default: false) */
+    wordDiff?: boolean;
+    /** Ignorar diferencias de espacios en blanco */
+    ignoreWhitespace?: boolean;
+}

package/dist/file/ignore.d.ts

@@ -0,0 +1,7 @@
+export declare namespace FileIgnore {
+    const PATTERNS: string[];
+    function match(filepath: string, opts?: {
+        extra?: Bun.Glob[];
+        whitelist?: Bun.Glob[];
+    }): boolean;
+}

package/dist/flag/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Environment flag accessors
+ *
+ * Uses getters for flags that need dynamic reading (important for tests),
+ * and static values for configuration that is read at startup.
+ */
+export declare namespace Flag {
+    const PORTER_CONFIG: string | undefined;
+    const PORTER_CONFIG_CONTENT: string | undefined;
+    const PORTER_CONFIG_DIR: string | undefined;
+    function getPermission(): string | undefined;
+    const PORTER_PERMISSION: string | undefined;
+    const PORTER_LOG_LEVEL: string | undefined;
+    const PORTER_LOG_PRINT: boolean;
+    const PORTER_DEV: boolean;
+    const PORTER_DISABLE_AUTO_OPTIMIZE: boolean;
+    const PORTER_DISABLE_PRUNE: boolean;
+    const PORTER_FAKE_VCS: string | undefined;
+}

package/dist/gateway/bridge.d.ts

@@ -0,0 +1,11 @@
+import { type PorterMessage } from "./protocol";
+export declare namespace Bridge {
+    /**
+     * Inicializa el bridge entre el Bus y el Gateway
+     */
+    function init(broadcast: (msg: PorterMessage) => void): void;
+    /**
+     * Detiene el bridge
+     */
+    function stop(): void;
+}

package/dist/gateway/handlers/llm.d.ts

@@ -0,0 +1,7 @@
+import { type PorterMessage, type ConnectedClient } from "../protocol";
+export declare namespace LLMHandler {
+    /**
+     * Maneja mensajes del canal "llm"
+     */
+    function handle(msg: PorterMessage, client: ConnectedClient): Promise<PorterMessage | void>;
+}

package/dist/gateway/handlers/permission.d.ts

@@ -0,0 +1,15 @@
+import { type PorterMessage, type ConnectedClient } from "../protocol";
+export declare namespace PermissionHandler {
+    /**
+     * Maneja mensajes del canal "permission"
+     */
+    function handle(msg: PorterMessage, client: ConnectedClient): Promise<PorterMessage | void>;
+    /**
+     * Registra un callback para una solicitud de permiso
+     */
+    function registerCallback(id: string, callback: (granted: boolean, pattern?: string) => void): void;
+    /**
+     * Limpia callbacks expirados
+     */
+    function clearCallback(id: string): void;
+}

package/dist/gateway/handlers/session.d.ts

@@ -0,0 +1,7 @@
+import { type PorterMessage, type ConnectedClient } from "../protocol";
+export declare namespace SessionHandler {
+    /**
+     * Maneja mensajes del canal "session"
+     */
+    function handle(msg: PorterMessage, client: ConnectedClient): Promise<PorterMessage | void>;
+}

package/dist/gateway/handlers/system.d.ts

@@ -0,0 +1,7 @@
+import { type PorterMessage, type ConnectedClient } from "../protocol";
+export declare namespace SystemHandler {
+    /**
+     * Maneja mensajes del canal "system"
+     */
+    function handle(msg: PorterMessage, client: ConnectedClient): Promise<PorterMessage | void>;
+}

package/dist/gateway/handlers/tool.d.ts

@@ -0,0 +1,7 @@
+import { type PorterMessage, type ConnectedClient } from "../protocol";
+export declare namespace ToolHandler {
+    /**
+     * Maneja mensajes del canal "tool"
+     */
+    function handle(msg: PorterMessage, client: ConnectedClient): Promise<PorterMessage | void>;
+}

package/dist/gateway/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Gateway Module (Legacy)
+ *
+ * WebSocket-based communication using Porter Wire Protocol (PWP).
+ *
+ * NOTE: The VS Code extension now uses HTTP + SSE instead.
+ * See src/server/ for the current HTTP server implementation.
+ * This module is kept for potential future use cases.
+ */
+export { Gateway } from "./server";
+export { Bridge } from "./bridge";
+export { Router } from "./router";
+export { type PorterMessage, type ConnectedClient, type GatewayInfo, type Channel, type MessageType, createRequest, createResponse, createEvent, createStream, createError, PorterMessage as PorterMessageSchema, GatewayInfo as GatewayInfoSchema, } from "./protocol";
+export { SessionHandler } from "./handlers/session";
+export { LLMHandler } from "./handlers/llm";
+export { ToolHandler } from "./handlers/tool";
+export { PermissionHandler } from "./handlers/permission";
+export { SystemHandler } from "./handlers/system";