portercode 0.1.4 → 0.1.11

package/dist/src/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/src/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/src/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/src/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/src/util/iife.d.ts

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

package/dist/src/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/src/util/lazy.d.ts

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

package/dist/src/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/src/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/src/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/src/util/timeout.d.ts

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

package/dist/src/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/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 = "Porter";
+/** CLI command name (lowercase, alphanumeric with hyphens) */
+export declare const PRODUCT_COMMAND = "porter";
+/** Configuration directory name (hidden folder in project/home) */
+export declare const CONFIG_DIR = ".porter";
+/** Configuration file name */
+export declare const CONFIG_FILE = "porter.jsonc";
+/** Rules/instructions file name */
+export declare const RULES_FILE = "PORTER.md";
+/** Environment variable prefix */
+export declare const ENV_PREFIX = "PORTER_";
+/** 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 ["PORTER.md", "AGENTS.md", "CONTEXT.md"];
+/** Global rule files searched in home directory */
+export declare const GLOBAL_RULE_FILES: readonly ["PORTER.md"];
+/** Default theme name */
+export declare const DEFAULT_THEME = "porter";
+/** Primary brand color (used for logo, highlights, etc.) */
+export declare const PRIMARY_COLOR = "#7c3aed";
+/** 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/image.d.ts

@@ -4,20 +4,19 @@ 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", "3:2", "2:3", "5:4", "4:5", "21:9"]>>;
+    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" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | 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" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | undefined;
+    aspectRatio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
 }>, {
     path: string;
     size: number;
     duration: string;
-    aspectRatio: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9";
 }>;

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/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/websearch.d.ts

@@ -0,0 +1,18 @@
+import z from "zod";
+import { Tool } from "./tool";
+export declare const WebSearchTool: Tool.Info<z.ZodObject<{
+    query: z.ZodString;
+    deep: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    deep?: boolean | undefined;
+}, {
+    query: string;
+    deep?: boolean | undefined;
+}>, {
+    query: string;
+    numQueries: number;
+    numResults: number;
+    numCitations: number;
+    deepSearch: boolean;
+}>;

package/dist/tools/think.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "../types/tool";
+export declare const thinkTool: Tool;

package/dist/tui/App.d.ts

@@ -6,5 +6,5 @@
 import type { TuiOptions } from "./index";
 interface AppProps extends TuiOptions {
 }
-export declare function App({ sessionId: initialSessionId, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
+export declare function App({ sessionId: initialSessionId, onExit, instanceContext }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -3,10 +3,11 @@
  *
  * 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 function Header({ title, mode }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare const Header: React.NamedExoticComponent<HeaderProps>;
 export {};