portercode 0.1.0

package/dist/tui/hooks/usePermission.d.ts

@@ -0,0 +1,26 @@
+/**
+ * usePermission Hook
+ *
+ * Manages permission request state and responses.
+ */
+export declare function usePermission(): {
+    pending: {
+        id: string;
+        tool: string;
+        action: string;
+        description: string;
+        risk: "low" | "medium" | "high";
+        details?: Record<string, any> | undefined;
+    }[];
+    current: {
+        id: string;
+        tool: string;
+        action: string;
+        description: string;
+        risk: "low" | "medium" | "high";
+        details?: Record<string, any> | undefined;
+    };
+    hasPending: boolean;
+    grant: (always?: boolean) => void;
+    deny: () => void;
+};

package/dist/tui/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TUI Entry Point
+ *
+ * Provides the main tui() function that renders the terminal interface.
+ */
+export { themes, getTheme, setTheme, getThemeNames } from "./theme";
+export type { Theme } from "./theme";
+export interface TuiOptions {
+    sessionId?: string;
+    onExit?: () => Promise<void>;
+}
+/**
+ * Start the Terminal User Interface
+ */
+export declare function tui(options?: TuiOptions): Promise<void>;

package/dist/tui/theme.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TUI Theme System
+ *
+ * Defines colors and styling for the terminal interface.
+ */
+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;
+}
+export declare const themes: Record<string, Theme>;
+export declare function getTheme(): Theme;
+export declare function setTheme(name: string): void;
+export declare function getThemeNames(): string[];

package/dist/tui/utils/Cursor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cursor Utility
+ *
+ * Manages cursor position for multiline text editing.
+ * Immutable class - all operations return new Cursor instances.
+ */
+export declare class Cursor {
+    readonly text: string;
+    readonly offset: number;
+    constructor(text: string, offset?: number);
+    get line(): number;
+    get column(): number;
+    get lines(): string[];
+    get currentLine(): string;
+    get textBefore(): string;
+    get textAfter(): string;
+    left(): Cursor;
+    right(): Cursor;
+    up(): Cursor;
+    down(): Cursor;
+    lineStart(): Cursor;
+    lineEnd(): Cursor;
+    start(): Cursor;
+    end(): Cursor;
+    nextWord(): Cursor;
+    prevWord(): Cursor;
+    insert(str: string): Cursor;
+    delete(): Cursor;
+    backspace(): Cursor;
+    deleteWord(): Cursor;
+    deleteWordBack(): Cursor;
+    deleteToEnd(): Cursor;
+    deleteToStart(): Cursor;
+    clear(): Cursor;
+    render(cursorChar?: string, showCursor?: boolean): string;
+    renderInverted(): string;
+}

package/dist/tui/utils/clipboard.d.ts

@@ -0,0 +1,3 @@
+export declare namespace Clipboard {
+    function copy(text: string): Promise<void>;
+}

package/dist/tui/utils/keypress.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Extended keypress detection for CSI u encoding and other special sequences.
+ *
+ * Some modern terminals (Kitty, WezTerm, iTerm2 with settings) support CSI u encoding
+ * which sends distinct sequences for modifier+key combinations.
+ *
+ * CSI u format: \x1b[<keycode>;<modifier>u
+ * Modifier bits: 1=Shift, 2=Alt, 4=Ctrl, 8=Super
+ *
+ * For Enter (keycode 13):
+ * - Enter:       \x1b[13u or just \r
+ * - Shift+Enter: \x1b[13;2u
+ * - Ctrl+Enter:  \x1b[13;5u
+ * - Alt+Enter:   \x1b[13;3u
+ */
+export interface ExtendedKey {
+    keycode: number;
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+}
+/**
+ * Parse CSI u encoded key sequence.
+ * Returns null if not a CSI u sequence.
+ */
+export declare function parseCSIu(sequence: string): ExtendedKey | null;
+/**
+ * Check if input represents Shift+Enter in any encoding.
+ */
+export declare function isShiftEnter(input: string, rawSequence?: string): boolean;
+/**
+ * Check if input represents Enter (with or without modifiers) using CSI u encoding.
+ */
+export declare function isEnterCSIu(input: string): {
+    isEnter: boolean;
+    shift: boolean;
+    ctrl: boolean;
+};

package/dist/tui/utils/markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Markdown Rendering for Terminal
+ *
+ * Converts markdown to styled terminal output using chalk.
+ */
+/**
+ * Render markdown to styled terminal text
+ */
+export declare function renderMarkdown(content: string): string;
+/**
+ * Truncate text to a maximum number of lines
+ */
+export declare function truncateLines(text: string, maxLines: number): string;

package/dist/tui/utils/openContent.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Open Content Utility
+ *
+ * Detects VS Code environment and opens content in appropriate viewer.
+ * Writes content to temp file and opens with VS Code or default app.
+ */
+/**
+ * Check if running inside VS Code terminal
+ */
+export declare function isVSCodeTerminal(): boolean;
+export interface OpenContentOptions {
+    toolName: string;
+    toolId: string;
+    args: Record<string, any>;
+    output: string;
+}
+/**
+ * Open tool output content in VS Code or default app
+ *
+ * Returns the path to the created temp file
+ */
+export declare function openToolContent(options: OpenContentOptions): string;

package/dist/util/context.d.ts

@@ -0,0 +1,10 @@
+export declare namespace Context {
+    class NotFound extends Error {
+        readonly name: string;
+        constructor(name: string);
+    }
+    function create<T>(name: string): {
+        use(): NonNullable<T>;
+        provide<R>(value: T, fn: () => R): R;
+    };
+}

package/dist/util/debug.d.ts

@@ -0,0 +1,51 @@
+export declare function initDebug(enabled: boolean): void;
+export declare function isDebugEnabled(): boolean;
+export declare function getDebugFilePath(): string;
+export declare function createDebugLogger(prefix: string): {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugCLI: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugSession: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugLLM: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugTool: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugStream: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugPermission: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
+export declare const debugUI: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};

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/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;
+}