portercode 0.1.0

package/dist/session/types.d.ts

@@ -0,0 +1,544 @@
+import z from "zod";
+/**
+ * Session and Message Type Definitions
+ */
+export declare const SessionId: z.ZodBranded<z.ZodString, "SessionId">;
+export type SessionId = z.infer<typeof SessionId>;
+export declare const MessageId: z.ZodBranded<z.ZodString, "MessageId">;
+export type MessageId = z.infer<typeof MessageId>;
+export declare const PartId: z.ZodBranded<z.ZodString, "PartId">;
+export type PartId = z.infer<typeof PartId>;
+/**
+ * Session information
+ */
+export declare const SessionInfo: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    directory: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    directory: string;
+    title: string;
+    projectId: string;
+    createdAt: number;
+    updatedAt: number;
+    parentId?: string | undefined;
+}, {
+    id: string;
+    directory: string;
+    title: string;
+    projectId: string;
+    createdAt: number;
+    updatedAt: number;
+    parentId?: string | undefined;
+}>;
+export type SessionInfo = z.infer<typeof SessionInfo>;
+/**
+ * Message roles
+ */
+export declare const MessageRole: z.ZodEnum<["user", "assistant", "system"]>;
+export type MessageRole = z.infer<typeof MessageRole>;
+/**
+ * Text content part
+ */
+export declare const TextPart: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}, {
+    type: "text";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}>;
+export type TextPart = z.infer<typeof TextPart>;
+/**
+ * Reasoning content part (for models with thinking)
+ */
+export declare const ReasoningPart: z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}, {
+    type: "reasoning";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}>;
+export type ReasoningPart = z.infer<typeof ReasoningPart>;
+/**
+ * Tool call part
+ */
+export declare const ToolCallPart: z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    toolId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodAny>;
+    state: z.ZodEnum<["pending", "running", "completed", "failed"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-call";
+    id: string;
+    state: "completed" | "pending" | "running" | "failed";
+    input: Record<string, any>;
+    sessionId: string;
+    toolId: string;
+    messageId: string;
+    toolName: string;
+}, {
+    type: "tool-call";
+    id: string;
+    state: "completed" | "pending" | "running" | "failed";
+    input: Record<string, any>;
+    sessionId: string;
+    toolId: string;
+    messageId: string;
+    toolName: string;
+}>;
+export type ToolCallPart = z.infer<typeof ToolCallPart>;
+/**
+ * Tool result part
+ */
+export declare const ToolResultPart: z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    output: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-result";
+    id: string;
+    output: string;
+    sessionId: string;
+    messageId: string;
+    toolCallId: string;
+    input?: Record<string, any> | undefined;
+    toolName?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    type: "tool-result";
+    id: string;
+    output: string;
+    sessionId: string;
+    messageId: string;
+    toolCallId: string;
+    input?: Record<string, any> | undefined;
+    toolName?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export type ToolResultPart = z.infer<typeof ToolResultPart>;
+/**
+ * All message part types
+ */
+export declare const MessagePart: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}, {
+    type: "text";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}, {
+    type: "reasoning";
+    id: string;
+    sessionId: string;
+    content: string;
+    messageId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    toolId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodAny>;
+    state: z.ZodEnum<["pending", "running", "completed", "failed"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-call";
+    id: string;
+    state: "completed" | "pending" | "running" | "failed";
+    input: Record<string, any>;
+    sessionId: string;
+    toolId: string;
+    messageId: string;
+    toolName: string;
+}, {
+    type: "tool-call";
+    id: string;
+    state: "completed" | "pending" | "running" | "failed";
+    input: Record<string, any>;
+    sessionId: string;
+    toolId: string;
+    messageId: string;
+    toolName: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    id: z.ZodString;
+    messageId: z.ZodString;
+    sessionId: z.ZodString;
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    output: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-result";
+    id: string;
+    output: string;
+    sessionId: string;
+    messageId: string;
+    toolCallId: string;
+    input?: Record<string, any> | undefined;
+    toolName?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    type: "tool-result";
+    id: string;
+    output: string;
+    sessionId: string;
+    messageId: string;
+    toolCallId: string;
+    input?: Record<string, any> | undefined;
+    toolName?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>]>;
+export type MessagePart = z.infer<typeof MessagePart>;
+/**
+ * Message information
+ */
+export declare const MessageInfo: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    role: z.ZodEnum<["user", "assistant", "system"]>;
+    createdAt: z.ZodNumber;
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    sessionId: string;
+    createdAt: number;
+    role: "system" | "user" | "assistant";
+    provider?: string | undefined;
+    model?: string | undefined;
+}, {
+    id: string;
+    sessionId: string;
+    createdAt: number;
+    role: "system" | "user" | "assistant";
+    provider?: string | undefined;
+    model?: string | undefined;
+}>;
+export type MessageInfo = z.infer<typeof MessageInfo>;
+/**
+ * Message with all its parts
+ */
+export declare const MessageWithParts: z.ZodObject<{
+    info: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodString;
+        role: z.ZodEnum<["user", "assistant", "system"]>;
+        createdAt: z.ZodNumber;
+        model: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        sessionId: string;
+        createdAt: number;
+        role: "system" | "user" | "assistant";
+        provider?: string | undefined;
+        model?: string | undefined;
+    }, {
+        id: string;
+        sessionId: string;
+        createdAt: number;
+        role: "system" | "user" | "assistant";
+        provider?: string | undefined;
+        model?: string | undefined;
+    }>;
+    parts: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        id: z.ZodString;
+        messageId: z.ZodString;
+        sessionId: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    }, {
+        type: "text";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"reasoning">;
+        id: z.ZodString;
+        messageId: z.ZodString;
+        sessionId: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "reasoning";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    }, {
+        type: "reasoning";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-call">;
+        id: z.ZodString;
+        messageId: z.ZodString;
+        sessionId: z.ZodString;
+        toolId: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodAny>;
+        state: z.ZodEnum<["pending", "running", "completed", "failed"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool-call";
+        id: string;
+        state: "completed" | "pending" | "running" | "failed";
+        input: Record<string, any>;
+        sessionId: string;
+        toolId: string;
+        messageId: string;
+        toolName: string;
+    }, {
+        type: "tool-call";
+        id: string;
+        state: "completed" | "pending" | "running" | "failed";
+        input: Record<string, any>;
+        sessionId: string;
+        toolId: string;
+        messageId: string;
+        toolName: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-result">;
+        id: z.ZodString;
+        messageId: z.ZodString;
+        sessionId: z.ZodString;
+        toolCallId: z.ZodString;
+        toolName: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        output: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool-result";
+        id: string;
+        output: string;
+        sessionId: string;
+        messageId: string;
+        toolCallId: string;
+        input?: Record<string, any> | undefined;
+        toolName?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        type: "tool-result";
+        id: string;
+        output: string;
+        sessionId: string;
+        messageId: string;
+        toolCallId: string;
+        input?: Record<string, any> | undefined;
+        toolName?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    info: {
+        id: string;
+        sessionId: string;
+        createdAt: number;
+        role: "system" | "user" | "assistant";
+        provider?: string | undefined;
+        model?: string | undefined;
+    };
+    parts: ({
+        type: "text";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    } | {
+        type: "reasoning";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    } | {
+        type: "tool-call";
+        id: string;
+        state: "completed" | "pending" | "running" | "failed";
+        input: Record<string, any>;
+        sessionId: string;
+        toolId: string;
+        messageId: string;
+        toolName: string;
+    } | {
+        type: "tool-result";
+        id: string;
+        output: string;
+        sessionId: string;
+        messageId: string;
+        toolCallId: string;
+        input?: Record<string, any> | undefined;
+        toolName?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    })[];
+}, {
+    info: {
+        id: string;
+        sessionId: string;
+        createdAt: number;
+        role: "system" | "user" | "assistant";
+        provider?: string | undefined;
+        model?: string | undefined;
+    };
+    parts: ({
+        type: "text";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    } | {
+        type: "reasoning";
+        id: string;
+        sessionId: string;
+        content: string;
+        messageId: string;
+    } | {
+        type: "tool-call";
+        id: string;
+        state: "completed" | "pending" | "running" | "failed";
+        input: Record<string, any>;
+        sessionId: string;
+        toolId: string;
+        messageId: string;
+        toolName: string;
+    } | {
+        type: "tool-result";
+        id: string;
+        output: string;
+        sessionId: string;
+        messageId: string;
+        toolCallId: string;
+        input?: Record<string, any> | undefined;
+        toolName?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    })[];
+}>;
+export type MessageWithParts = z.infer<typeof MessageWithParts>;
+/**
+ * Token usage statistics
+ */
+export declare const TokenUsage: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    reasoning: z.ZodOptional<z.ZodNumber>;
+    cached: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    input: number;
+    output: number;
+    reasoning?: number | undefined;
+    cached?: number | undefined;
+}, {
+    input: number;
+    output: number;
+    reasoning?: number | undefined;
+    cached?: number | undefined;
+}>;
+export type TokenUsage = z.infer<typeof TokenUsage>;
+/**
+ * Cost calculation result
+ */
+export declare const UsageCost: z.ZodObject<{
+    tokens: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        reasoning?: number | undefined;
+        cached?: number | undefined;
+    }, {
+        input: number;
+        output: number;
+        reasoning?: number | undefined;
+        cached?: number | undefined;
+    }>;
+    cost: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    cost: number;
+    tokens: {
+        input: number;
+        output: number;
+        reasoning?: number | undefined;
+        cached?: number | undefined;
+    };
+}, {
+    cost: number;
+    tokens: {
+        input: number;
+        output: number;
+        reasoning?: number | undefined;
+        cached?: number | undefined;
+    };
+}>;
+export type UsageCost = z.infer<typeof UsageCost>;

package/dist/snapshot/index.d.ts

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

package/dist/storage/index.d.ts

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

package/dist/storage/storage.d.ts

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

package/dist/tool/bash.d.ts

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

package/dist/tool/edit.d.ts

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

package/dist/tool/glob.d.ts

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

package/dist/tool/grep.d.ts

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