@selesai/code 0.10.2 → 0.11.0

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/skills.d.ts

@@ -0,0 +1,60 @@
+import type { ResourceDiagnostic } from "./diagnostics.ts";
+import { type SourceInfo } from "./source-info.ts";
+export interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    "disable-model-invocation"?: boolean;
+    [key: string]: unknown;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    filePath: string;
+    baseDir: string;
+    sourceInfo: SourceInfo;
+    disableModelInvocation: boolean;
+}
+export interface LoadSkillsResult {
+    skills: Skill[];
+    diagnostics: ResourceDiagnostic[];
+}
+export interface LoadSkillsFromDirOptions {
+    /** Directory to scan for skills */
+    dir: string;
+    /** Source identifier for these skills */
+    source: string;
+}
+/**
+ * Load skills from a directory.
+ *
+ * Discovery rules:
+ * - if a directory contains SKILL.md, treat it as a skill root and do not recurse further
+ * - otherwise, load direct .md children in the root
+ * - recurse into subdirectories to find SKILL.md
+ */
+export declare function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkillsResult;
+/**
+ * Format skills for inclusion in a system prompt.
+ * Uses XML format per Agent Skills standard.
+ * See: https://agentskills.io/integrate-skills
+ *
+ * Skills with disableModelInvocation=true are excluded from the prompt
+ * (they can only be invoked explicitly via /skill:name commands).
+ */
+export declare function formatSkillsForPrompt(skills: Skill[]): string;
+export interface LoadSkillsOptions {
+    /** Working directory for project-local skills. */
+    cwd: string;
+    /** Agent config directory for global skills. */
+    agentDir: string;
+    /** Explicit skill paths (files or directories) */
+    skillPaths: string[];
+    /** Include default skills directories. */
+    includeDefaults: boolean;
+}
+/**
+ * Load skills from all configured locations.
+ * Returns skills and any validation diagnostics.
+ */
+export declare function loadSkills(options: LoadSkillsOptions): LoadSkillsResult;
+//# sourceMappingURL=skills.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/slash-commands.d.ts

@@ -0,0 +1,15 @@
+import type { SourceInfo } from "./source-info.ts";
+export type SlashCommandSource = "extension" | "prompt" | "skill";
+export interface SlashCommandInfo {
+    name: string;
+    description?: string;
+    source: SlashCommandSource;
+    sourceInfo: SourceInfo;
+}
+export interface BuiltinSlashCommand {
+    name: string;
+    description: string;
+    argumentHint?: string;
+}
+export declare const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand>;
+//# sourceMappingURL=slash-commands.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/source-info.d.ts

@@ -0,0 +1,18 @@
+import type { PathMetadata } from "./package-manager.ts";
+export type SourceScope = "user" | "project" | "temporary";
+export type SourceOrigin = "package" | "top-level";
+export interface SourceInfo {
+    path: string;
+    source: string;
+    scope: SourceScope;
+    origin: SourceOrigin;
+    baseDir?: string;
+}
+export declare function createSourceInfo(path: string, metadata: PathMetadata): SourceInfo;
+export declare function createSyntheticSourceInfo(path: string, options: {
+    source: string;
+    scope?: SourceScope;
+    origin?: SourceOrigin;
+    baseDir?: string;
+}): SourceInfo;
+//# sourceMappingURL=source-info.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/system-prompt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * System prompt construction and project context loading
+ */
+import { type Skill } from "./skills.ts";
+export interface BuildSystemPromptOptions {
+    /** Custom system prompt (replaces default). */
+    customPrompt?: string;
+    /** Tools to include in prompt. Default: [read, bash, edit, write] */
+    selectedTools?: string[];
+    /** Optional one-line tool snippets keyed by tool name. */
+    toolSnippets?: Record<string, string>;
+    /** Additional guideline bullets appended to the default system prompt guidelines. */
+    promptGuidelines?: string[];
+    /** Text to append to system prompt. */
+    appendSystemPrompt?: string;
+    /** Working directory. */
+    cwd: string;
+    /** Pre-loaded context files. */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** Pre-loaded skills. */
+    skills?: Skill[];
+}
+/** Build the system prompt with tools, guidelines, and context */
+export declare function buildSystemPrompt(options: BuildSystemPromptOptions): string;
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/telemetry.d.ts

@@ -0,0 +1,3 @@
+import type { SettingsManager } from "./settings-manager.ts";
+export declare function isInstallTelemetryEnabled(settingsManager: SettingsManager, telemetryEnv?: string | undefined): boolean;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/timings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with PI_TIMING=1 environment variable.
+ */
+type TimingLabel = "main" | "extensions";
+export declare function resetTimings(namespace?: TimingLabel): void;
+export declare function time(label: string, namespace?: TimingLabel): void;
+export declare function printTimings(): void;
+export {};
+//# sourceMappingURL=timings.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/bash.d.ts

@@ -0,0 +1,68 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const bashSchema: Type.TObject<{
+    command: Type.TString;
+    timeout: Type.TOptional<Type.TNumber>;
+}>;
+export type BashToolInput = Static<typeof bashSchema>;
+export interface BashToolDetails {
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Pluggable operations for the bash tool.
+ * Override these to delegate command execution to remote systems (for example SSH).
+ */
+export interface BashOperations {
+    /**
+     * Execute a command and stream output.
+     * @param command The command to execute
+     * @param cwd Working directory
+     * @param options Execution options
+     * @returns Promise resolving to exit code (null if killed)
+     */
+    exec: (command: string, cwd: string, options: {
+        onData: (data: Buffer) => void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        exitCode: number | null;
+    }>;
+}
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export declare function createLocalBashOperations(options?: {
+    shellPath?: string;
+}): BashOperations;
+export interface BashSpawnContext {
+    command: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
+export interface BashToolOptions {
+    /** Custom operations for command execution. Default: local shell */
+    operations?: BashOperations;
+    /** Command prefix prepended to every command (for example shell setup commands) */
+    commandPrefix?: string;
+    /** Optional explicit shell path from settings */
+    shellPath?: string;
+    /** Hook to adjust command, cwd, or env before execution */
+    spawnHook?: BashSpawnHook;
+}
+type BashRenderState = {
+    startedAt: number | undefined;
+    endedAt: number | undefined;
+    interval: NodeJS.Timeout | undefined;
+};
+export declare function createBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
+export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
+export {};
+//# sourceMappingURL=bash.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/edit-diff.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared diff computation utilities for the edit and similar tools.
+ */
+export declare function detectLineEnding(content: string): "\r\n" | "\n";
+export declare function normalizeToLF(text: string): string;
+export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
+/**
+ * Normalize text for fuzzy matching. Applies progressive transformations:
+ * - Strip trailing whitespace from each line
+ * - Normalize smart quotes to ASCII equivalents
+ * - Normalize Unicode dashes/hyphens to ASCII hyphen
+ * - Normalize special Unicode spaces to regular space
+ */
+export declare function normalizeForFuzzyMatch(text: string): string;
+interface MatchedEdit {
+    editIndex: number;
+    matchIndex: number;
+    matchLength: number;
+    newText: string;
+}
+type TextReplacement = Pick<MatchedEdit, "matchIndex" | "matchLength" | "newText">;
+/**
+ * Apply replacements matched against `baseContent` to `originalContent` while
+ * preserving unchanged line blocks from the original.
+ *
+ * This is useful when `baseContent` is a normalized view of the original. Each
+ * replacement is widened to the lines it actually touches, those touched lines
+ * are rewritten from the normalized base, and all other lines are copied back
+ * from `originalContent`. The actual replacement ranges drive preservation so
+ * duplicate normalized lines cannot be aligned to the wrong occurrence.
+ */
+export declare function applyReplacementsPreservingUnchangedLines(originalContent: string, baseContent: string, replacements: TextReplacement[]): string;
+export interface FuzzyMatchResult {
+    /** Whether a match was found */
+    found: boolean;
+    /** The index where the match starts (in the content that should be used for replacement) */
+    index: number;
+    /** Length of the matched text */
+    matchLength: number;
+    /** Whether fuzzy matching was used (false = exact match) */
+    usedFuzzyMatch: boolean;
+    /**
+     * The content to use for replacement operations.
+     * When exact match: original content. When fuzzy match: normalized content.
+     */
+    contentForReplacement: string;
+}
+export interface Edit {
+    oldText: string;
+    newText: string;
+}
+export interface AppliedEditsResult {
+    baseContent: string;
+    newContent: string;
+}
+/**
+ * Find oldText in content, trying exact match first, then fuzzy match.
+ * When fuzzy matching is used, the returned contentForReplacement is the
+ * fuzzy-normalized version of the content (trailing whitespace stripped,
+ * Unicode quotes/dashes normalized to ASCII).
+ */
+export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
+/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
+export declare function stripBom(content: string): {
+    bom: string;
+    text: string;
+};
+/**
+ * Apply one or more exact-text replacements to LF-normalized content.
+ *
+ * All edits are matched against the same original content. Replacements are
+ * then applied in reverse order so offsets remain stable. If any edit needs
+ * fuzzy matching, the operation runs in fuzzy-normalized content space and then
+ * overlays those line-level changes onto the original content so unchanged line
+ * blocks keep their original bytes.
+ */
+export declare function applyEditsToNormalizedContent(normalizedContent: string, edits: Edit[], path: string): AppliedEditsResult;
+/** Generate a standard unified patch. */
+export declare function generateUnifiedPatch(path: string, oldContent: string, newContent: string, contextLines?: number): string;
+/**
+ * Generate a display-oriented diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): {
+    diff: string;
+    firstChangedLine: number | undefined;
+};
+export interface EditDiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface EditDiffError {
+    error: string;
+}
+/**
+ * Compute the diff for one or more edit operations without applying them.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditsDiff(path: string, edits: Edit[], cwd: string): Promise<EditDiffResult | EditDiffError>;
+/**
+ * Compute the diff for a single edit operation without applying it.
+ * Kept as a convenience wrapper for single-edit callers.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string): Promise<EditDiffResult | EditDiffError>;
+export {};
+//# sourceMappingURL=edit-diff.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/edit.d.ts

@@ -0,0 +1,51 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { Box } from "@earendil-works/pi-tui";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type EditDiffError, type EditDiffResult } from "./edit-diff.ts";
+type EditPreview = EditDiffResult | EditDiffError;
+type EditRenderState = {
+    callComponent?: EditCallRenderComponent;
+};
+declare const editSchema: Type.TObject<{
+    path: Type.TString;
+    edits: Type.TArray<Type.TObject<{
+        oldText: Type.TString;
+        newText: Type.TString;
+    }>>;
+}>;
+export type EditToolInput = Static<typeof editSchema>;
+export interface EditToolDetails {
+    /** Display-oriented diff of the changes made */
+    diff: string;
+    /** Standard unified patch of the changes made */
+    patch: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+}
+/**
+ * Pluggable operations for the edit tool.
+ * Override these to delegate file editing to remote systems (for example SSH).
+ */
+export interface EditOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Write content to a file */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Check if file is readable and writable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    /** Custom operations for file editing. Default: local filesystem */
+    operations?: EditOperations;
+}
+type EditCallRenderComponent = Box & {
+    preview?: EditPreview;
+    previewArgsKey?: string;
+    previewPending?: boolean;
+    settledError?: boolean;
+};
+export declare function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition<typeof editSchema, EditToolDetails | undefined, EditRenderState>;
+export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
+export {};
+//# sourceMappingURL=edit.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/file-mutation-queue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize file mutation operations targeting the same file.
+ * Operations for different files still run in parallel.
+ */
+export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=file-mutation-queue.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/find.d.ts

@@ -0,0 +1,35 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const findSchema: Type.TObject<{
+    pattern: Type.TString;
+    path: Type.TOptional<Type.TString>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export type FindToolInput = Static<typeof findSchema>;
+export interface FindToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+}
+/**
+ * Pluggable operations for the find tool.
+ * Override these to delegate file search to remote systems (for example SSH).
+ */
+export interface FindOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Find files matching glob pattern. Returns relative or absolute paths. */
+    glob: (pattern: string, cwd: string, options: {
+        ignore: string[];
+        limit: number;
+    }) => Promise<string[]> | string[];
+}
+export interface FindToolOptions {
+    /** Custom operations for find. Default: local filesystem plus fd */
+    operations?: FindOperations;
+}
+export declare function createFindToolDefinition(cwd: string, options?: FindToolOptions): ToolDefinition<typeof findSchema, FindToolDetails | undefined>;
+export declare function createFindTool(cwd: string, options?: FindToolOptions): AgentTool<typeof findSchema>;
+export {};
+//# sourceMappingURL=find.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/grep.d.ts

@@ -0,0 +1,37 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const grepSchema: Type.TObject<{
+    pattern: Type.TString;
+    path: Type.TOptional<Type.TString>;
+    glob: Type.TOptional<Type.TString>;
+    ignoreCase: Type.TOptional<Type.TBoolean>;
+    literal: Type.TOptional<Type.TBoolean>;
+    context: Type.TOptional<Type.TNumber>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export type GrepToolInput = Static<typeof grepSchema>;
+export interface GrepToolDetails {
+    truncation?: TruncationResult;
+    matchLimitReached?: number;
+    linesTruncated?: boolean;
+}
+/**
+ * Pluggable operations for the grep tool.
+ * Override these to delegate search to remote systems (for example SSH).
+ */
+export interface GrepOperations {
+    /** Check if path is a directory. Throws if path does not exist. */
+    isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Read file contents for context lines */
+    readFile: (absolutePath: string) => Promise<string> | string;
+}
+export interface GrepToolOptions {
+    /** Custom operations for grep. Default: local filesystem plus ripgrep */
+    operations?: GrepOperations;
+}
+export declare function createGrepToolDefinition(cwd: string, options?: GrepToolOptions): ToolDefinition<typeof grepSchema, GrepToolDetails | undefined>;
+export declare function createGrepTool(cwd: string, options?: GrepToolOptions): AgentTool<typeof grepSchema>;
+export {};
+//# sourceMappingURL=grep.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/index.d.ts

@@ -0,0 +1,40 @@
+export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.ts";
+export { createEditTool, createEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, } from "./edit.ts";
+export { withFileMutationQueue } from "./file-mutation-queue.ts";
+export { createFindTool, createFindToolDefinition, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, } from "./find.ts";
+export { createGrepTool, createGrepToolDefinition, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, } from "./grep.ts";
+export { createLsTool, createLsToolDefinition, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, } from "./ls.ts";
+export { createReadTool, createReadToolDefinition, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, } from "./read.ts";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.ts";
+export { createWriteTool, createWriteToolDefinition, type WriteOperations, type WriteToolInput, type WriteToolOptions, } from "./write.ts";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type BashToolOptions } from "./bash.ts";
+import { type EditToolOptions } from "./edit.ts";
+import { type FindToolOptions } from "./find.ts";
+import { type GrepToolOptions } from "./grep.ts";
+import { type LsToolOptions } from "./ls.ts";
+import { type ReadToolOptions } from "./read.ts";
+import { type WriteToolOptions } from "./write.ts";
+export type Tool = AgentTool<any>;
+export type ToolDef = ToolDefinition<any, any>;
+export type ToolName = "read" | "bash" | "edit" | "write" | "grep" | "find" | "ls";
+export declare const allToolNames: Set<ToolName>;
+export interface ToolsOptions {
+    read?: ReadToolOptions;
+    bash?: BashToolOptions;
+    write?: WriteToolOptions;
+    edit?: EditToolOptions;
+    grep?: GrepToolOptions;
+    find?: FindToolOptions;
+    ls?: LsToolOptions;
+}
+export declare function createToolDefinition(toolName: ToolName, cwd: string, options?: ToolsOptions): ToolDef;
+export declare function createTool(toolName: ToolName, cwd: string, options?: ToolsOptions): Tool;
+export declare function createCodingToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[];
+export declare function createReadOnlyToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[];
+export declare function createAllToolDefinitions(cwd: string, options?: ToolsOptions): Record<ToolName, ToolDef>;
+export declare function createCodingTools(cwd: string, options?: ToolsOptions): Tool[];
+export declare function createReadOnlyTools(cwd: string, options?: ToolsOptions): Tool[];
+export declare function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool>;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/ls.d.ts

@@ -0,0 +1,37 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const lsSchema: Type.TObject<{
+    path: Type.TOptional<Type.TString>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export type LsToolInput = Static<typeof lsSchema>;
+export interface LsToolDetails {
+    truncation?: TruncationResult;
+    entryLimitReached?: number;
+}
+/**
+ * Pluggable operations for the ls tool.
+ * Override these to delegate directory listing to remote systems (for example SSH).
+ */
+export interface LsOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Get file or directory stats. Throws if not found. */
+    stat: (absolutePath: string) => Promise<{
+        isDirectory: () => boolean;
+    }> | {
+        isDirectory: () => boolean;
+    };
+    /** Read directory entries */
+    readdir: (absolutePath: string) => Promise<string[]> | string[];
+}
+export interface LsToolOptions {
+    /** Custom operations for directory listing. Default: local filesystem */
+    operations?: LsOperations;
+}
+export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition<typeof lsSchema, LsToolDetails | undefined>;
+export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
+export {};
+//# sourceMappingURL=ls.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/output-accumulator.d.ts

@@ -0,0 +1,52 @@
+import { type TruncationResult } from "./truncate.ts";
+export interface OutputAccumulatorOptions {
+    maxLines?: number;
+    maxBytes?: number;
+    tempFilePrefix?: string;
+}
+export interface OutputSnapshot {
+    content: string;
+    truncation: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
+ * tail for display snapshots, and opens a temp file when the full output needs
+ * to be preserved.
+ */
+export declare class OutputAccumulator {
+    private readonly maxLines;
+    private readonly maxBytes;
+    private readonly maxRollingBytes;
+    private readonly tempFilePrefix;
+    private readonly decoder;
+    private rawChunks;
+    private tailText;
+    private tailBytes;
+    private tailStartsAtLineBoundary;
+    private totalRawBytes;
+    private totalDecodedBytes;
+    private completedLines;
+    private totalLines;
+    private currentLineBytes;
+    private hasOpenLine;
+    private finished;
+    private tempFilePath;
+    private tempFileStream;
+    constructor(options?: OutputAccumulatorOptions);
+    append(data: Buffer): void;
+    finish(): void;
+    snapshot(options?: {
+        persistIfTruncated?: boolean;
+    }): OutputSnapshot;
+    closeTempFile(): Promise<void>;
+    getLastLineBytes(): number;
+    private appendDecodedText;
+    private trimTail;
+    private getSnapshotText;
+    private shouldUseTempFile;
+    private ensureTempFile;
+}
+//# sourceMappingURL=output-accumulator.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/path-utils.d.ts

@@ -0,0 +1,10 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function expandPath(filePath: string): string;
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function resolveReadPath(filePath: string, cwd: string): string;
+export declare function resolveReadPathAsync(filePath: string, cwd: string): Promise<string>;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/read.d.ts

@@ -0,0 +1,35 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const readSchema: Type.TObject<{
+    path: Type.TString;
+    offset: Type.TOptional<Type.TNumber>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export type ReadToolInput = Static<typeof readSchema>;
+export interface ReadToolDetails {
+    truncation?: TruncationResult;
+}
+/**
+ * Pluggable operations for the read tool.
+ * Override these to delegate file reading to remote systems (for example SSH).
+ */
+export interface ReadOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Check if file is readable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+    /** Detect image MIME type, return null or undefined for non-images */
+    detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
+}
+export interface ReadToolOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+    /** Custom operations for file reading. Default: local filesystem */
+    operations?: ReadOperations;
+}
+export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined>;
+export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
+export {};
+//# sourceMappingURL=read.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/tools/render-utils.d.ts

@@ -0,0 +1,24 @@
+import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
+import type { Theme } from "../../modes/interactive/theme/theme.ts";
+export declare function shortenPath(path: unknown): string;
+export declare function linkPath(styledText: string, rawPath: string, cwd: string): string;
+export declare function str(value: unknown): string | null;
+export declare function replaceTabs(text: string): string;
+export declare function normalizeDisplayText(text: string): string;
+export declare function getTextOutput(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+} | undefined, showImages: boolean): string;
+export type ToolRenderResultLike<TDetails> = {
+    content: (TextContent | ImageContent)[];
+    details: TDetails;
+};
+export declare function invalidArgText(theme: Theme): string;
+export declare function renderToolPath(rawPath: string | null, theme: Theme, cwd: string, options?: {
+    emptyFallback?: string;
+}): string;
+//# sourceMappingURL=render-utils.d.ts.map