bioscode 0.1.5

package/dist/util/error.d.ts

@@ -0,0 +1,294 @@
+import z from "zod";
+export declare abstract class NamedError extends Error {
+    abstract schema(): z.ZodType;
+    abstract toObject(): {
+        name: string;
+        data: any;
+    };
+    static 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;
+    };
+    static 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;
+    };
+}

package/dist/util/example-commands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Example Commands
+ *
+ * Generates contextual example commands for the prompt placeholder.
+ * Similar to code-cli's example suggestions.
+ */
+/**
+ * Generate a contextual example command
+ */
+export declare function getExampleCommand(): string;
+/**
+ * Get placeholder text with example command
+ */
+export declare function getPlaceholder(): string;
+/**
+ * Get multiple unique examples
+ */
+export declare function getExamples(count?: number): string[];

package/dist/util/filesystem.d.ts

@@ -0,0 +1,17 @@
+export declare namespace Filesystem {
+    /**
+     * On Windows, normalize a path to its canonical casing using the filesystem.
+     * This is needed because Windows paths are case-insensitive but LSP servers
+     * may return paths with different casing than what we send them.
+     */
+    function normalizePath(p: string): string;
+    function overlaps(a: string, b: string): boolean;
+    function contains(parent: string, child: string): boolean;
+    function findUp(target: string, start: string, stop?: string): Promise<string[]>;
+    function up(options: {
+        targets: string[];
+        start: string;
+        stop?: string;
+    }): AsyncGenerator<string, void, unknown>;
+    function globUp(pattern: string, start: string, stop?: string): Promise<string[]>;
+}

package/dist/util/id.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ID Generation Utilities
+ *
+ * Provides unique identifier generation for sessions, messages, and parts.
+ * Uses timestamp-based sorting with random suffixes for uniqueness.
+ */
+/**
+ * Generate a timestamp-based ID (ascending order - newer IDs are larger)
+ */
+export declare function ascending(prefix: string): string;
+/**
+ * Generate a timestamp-based ID (descending order - newer IDs are smaller)
+ * Useful for listing sessions in reverse chronological order
+ */
+export declare function descending(prefix: string): string;
+/**
+ * Generate IDs with specific prefixes
+ */
+export declare const Id: {
+    session: () => string;
+    message: () => string;
+    part: () => string;
+    random: (prefix?: string) => string;
+};

package/dist/util/iife.d.ts

@@ -0,0 +1 @@
+export declare function iife<T>(fn: () => T): T;

package/dist/util/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./context";
+export * from "./lazy";
+export * from "./log";
+export * from "./error";
+export * from "./iife";
+export * from "./filesystem";
+export * from "./id";

package/dist/util/lazy.d.ts

@@ -0,0 +1 @@
+export declare function lazy<T>(fn: () => T): () => T;

package/dist/util/log.d.ts

@@ -0,0 +1,26 @@
+import z from "zod";
+export declare namespace Log {
+    const Level: z.ZodEnum<["DEBUG", "INFO", "WARN", "ERROR"]>;
+    type Level = z.infer<typeof Level>;
+    type Logger = {
+        debug(message?: any, extra?: Record<string, any>): void;
+        info(message?: any, extra?: Record<string, any>): void;
+        error(message?: any, extra?: Record<string, any>): void;
+        warn(message?: any, extra?: Record<string, any>): void;
+        tag(key: string, value: string): Logger;
+        clone(): Logger;
+        time(message: string, extra?: Record<string, any>): {
+            stop(): void;
+            [Symbol.dispose](): void;
+        };
+    };
+    const Default: Logger;
+    interface Options {
+        print: boolean;
+        dev?: boolean;
+        level?: Level;
+    }
+    function file(): string;
+    function init(options: Options): Promise<void>;
+    function create(tags?: Record<string, any>): Logger;
+}

package/dist/util/paths.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Cross-platform path utilities
+ * Helps handle file paths correctly across Windows, macOS, and Linux
+ */
+/**
+ * Resolve home directory paths (~/...)
+ * Works cross-platform (Windows, macOS, Linux)
+ *
+ * @param filepath - Path that may start with ~/
+ * @returns Resolved absolute path
+ *
+ * @example
+ * resolveHomePath("~/Documents/file.txt")
+ * // Windows: C:\Users\username\Documents\file.txt
+ * // macOS: /Users/username/Documents/file.txt
+ * // Linux: /home/username/Documents/file.txt
+ */
+export declare function resolveHomePath(filepath: string): string;
+/**
+ * Get platform-specific config directory for an application
+ *
+ * @param commandName - Name of the command/application
+ * @returns Platform-appropriate config directory path
+ *
+ * @example
+ * getConfigDir("portercode")
+ * // Windows: C:\Users\username\AppData\Roaming\portercode
+ * // macOS: /Users/username/Library/Application Support/portercode
+ * // Linux: /home/username/.config/portercode
+ */
+export declare function getConfigDir(commandName: string): string;
+/**
+ * Get platform-specific data directory for an application
+ * This is where app data files are typically stored
+ *
+ * @param commandName - Name of the command/application
+ * @returns Platform-appropriate data directory path
+ *
+ * @example
+ * getDataDir("portercode")
+ * // Windows: C:\Users\username\AppData\Local\portercode
+ * // macOS: /Users/username/Library/Application Support/portercode
+ * // Linux: /home/username/.local/share/portercode
+ */
+export declare function getDataDir(commandName: string): string;

package/dist/util/shell.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shell Utilities
+ *
+ * Manages shell aliases and RC files across different shells
+ */
+export declare namespace ShellUtils {
+    type Shell = "bash" | "zsh" | "fish" | "powershell" | "unknown";
+    /**
+     * Detect current shell
+     */
+    function detectShell(): Shell;
+    /**
+     * Get shell RC file path
+     */
+    function getShellRc(shell?: Shell): string;
+    /**
+     * Create alias in shell RC file
+     */
+    function createAlias(aliasName: string, targetCommand: string, shell?: Shell): Promise<{
+        success: boolean;
+        rcFile: string;
+        message: string;
+    }>;
+    /**
+     * Remove alias from shell RC file
+     */
+    function removeAlias(aliasName: string, shell?: Shell): Promise<{
+        success: boolean;
+        rcFile: string;
+        message: string;
+    }>;
+    /**
+     * Check if alias exists in shell RC files
+     */
+    function hasAlias(aliasName: string, shell?: Shell): Promise<boolean>;
+}

package/dist/util/timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;

package/dist/util/wildcard.d.ts

@@ -0,0 +1,8 @@
+export declare namespace Wildcard {
+    function match(str: string, pattern: string): boolean;
+    function all(input: string, patterns: Record<string, any>): any;
+    function allStructured(input: {
+        head: string;
+        tail: string[];
+    }, patterns: Record<string, any>): any;
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "bioscode",
+  "version": "0.1.5",
+  "description": "AI-powered coding assistant CLI",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "bioscode": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "bun run ./src/index.ts",
+    "build": "bun run build.ts",
+    "build:windows": "bun run build-windows.ts",
+    "build:windows-portable": "bun run build-windows-portable.ts",
+    "build:windows-installer": "bun run build-windows-installer.ts",
+    "build:distributions": "bun run build-distributions.ts",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding-assistant",
+    "llm"
+  ],
+  "author": "Carlos Alexis Gomez Ruiz <alexisg.0207@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "devDependencies": {
+    "@tsconfig/bun": "^1.0.7",
+    "@types/bun": "^1.2.14",
+    "@types/react": "^18.2.0",
+    "@types/yargs": "^17.0.33",
+    "javascript-obfuscator": "^5.1.0",
+    "puppeteer": "^24.34.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.1",
+    "@ai-sdk/google": "^3.0.1",
+    "@ai-sdk/google-vertex": "^4.0.9",
+    "@ai-sdk/groq": "^3.0.1",
+    "@ai-sdk/openai": "^3.0.1",
+    "@ai-sdk/provider": "^2.0.0",
+    "@clack/prompts": "^0.11.0",
+    "@inkjs/ui": "^2.0.0",
+    "@modelcontextprotocol/sdk": "^1.15.1",
+    "ai": "^6.0.3",
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "clipboardy": "^5.0.2",
+    "crawlee": "^3.15.3",
+    "diff": "^7.0.0",
+    "figures": "^6.0.1",
+    "google-auth-library": "^10.5.0",
+    "gray-matter": "^4.0.3",
+    "hono": "^4.11.3",
+    "ignore": "^7.0.5",
+    "ink": "^5.0.1",
+    "jsonc-parser": "^3.3.1",
+    "marked": "^12.0.0",
+    "minimatch": "^10.0.3",
+    "playwright": "^1.49.0",
+    "react": "^18.2.0",
+    "react-devtools-core": "^7.0.1",
+    "ulid": "^2.3.0",
+    "wrap-ansi": "^9.0.0",
+    "xdg-basedir": "^5.1.0",
+    "yargs": "^18.0.0",
+    "zod": "^3.24.5",
+    "zod-to-json-schema": "^3.25.1"
+  }
+}