terminal-pilot 0.0.30 → 0.0.32

package/node_modules/@poe-code/config-mutations/dist/mutations/config-mutation.d.ts

@@ -0,0 +1,47 @@
+import type { ConfigMergeMutation, ConfigPruneMutation, ConfigTransformMutation, ConfigObject, ValueResolver, MutationOptions } from "../types.js";
+export interface MergeOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Value to merge into the config file */
+    value: ValueResolver<ConfigObject>;
+    /** Optional explicit format override */
+    format?: "json" | "toml" | "yaml";
+    /** Optional prune by prefix before merging (TOML) */
+    pruneByPrefix?: Record<string, string>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface PruneOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Shape to prune from the config file */
+    shape: ValueResolver<ConfigObject>;
+    /** Optional explicit format override */
+    format?: "json" | "toml" | "yaml";
+    /** Optional guard - only prune if predicate returns true */
+    onlyIf?: (doc: ConfigObject, ctx: MutationOptions) => boolean;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface TransformOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Optional explicit format override */
+    format?: "json" | "toml" | "yaml";
+    /** Transform function - receives parsed content, returns transformed content */
+    transform: (content: ConfigObject, ctx: MutationOptions) => {
+        content: ConfigObject | null;
+        changed: boolean;
+    };
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+declare function merge(options: MergeOptions): ConfigMergeMutation;
+declare function prune(options: PruneOptions): ConfigPruneMutation;
+declare function transform(options: TransformOptions): ConfigTransformMutation;
+export declare const configMutation: {
+    merge: typeof merge;
+    prune: typeof prune;
+    transform: typeof transform;
+};
+export {};

package/node_modules/@poe-code/config-mutations/dist/mutations/config-mutation.js

@@ -0,0 +1,34 @@
+function merge(options) {
+    return {
+        kind: "configMerge",
+        target: options.target,
+        value: options.value,
+        format: options.format,
+        pruneByPrefix: options.pruneByPrefix,
+        label: options.label
+    };
+}
+function prune(options) {
+    return {
+        kind: "configPrune",
+        target: options.target,
+        shape: options.shape,
+        format: options.format,
+        onlyIf: options.onlyIf,
+        label: options.label
+    };
+}
+function transform(options) {
+    return {
+        kind: "configTransform",
+        target: options.target,
+        format: options.format,
+        transform: options.transform,
+        label: options.label
+    };
+}
+export const configMutation = {
+    merge,
+    prune,
+    transform
+};

package/node_modules/@poe-code/config-mutations/dist/mutations/file-mutation.d.ts

@@ -0,0 +1,62 @@
+import type { EnsureDirectoryMutation, RemoveDirectoryMutation, RemoveFileMutation, ChmodMutation, BackupMutation, RestoreBackupMutation, ValueResolver } from "../types.js";
+export interface EnsureDirectoryOptions {
+    /** Directory path (must start with ~) */
+    path: ValueResolver<string>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface RemoveOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Only remove if file is empty/whitespace */
+    whenEmpty?: boolean;
+    /** Only remove if content matches regex */
+    whenContentMatches?: RegExp;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface RemoveDirectoryOptions {
+    /** Directory path (must start with ~) */
+    path: ValueResolver<string>;
+    /** Remove directory even when not empty */
+    force?: boolean;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface ChmodOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** File permission mode (e.g., 0o755) */
+    mode: number;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface BackupOptions {
+    /** Target file path to backup (must start with ~) */
+    target: ValueResolver<string>;
+    /** Keep the first baseline only, including an originally missing target. */
+    once?: boolean;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface RestoreBackupOptions {
+    /** Target file path whose latest generated backup should be restored. */
+    target: ValueResolver<string>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+declare function ensureDirectory(options: EnsureDirectoryOptions): EnsureDirectoryMutation;
+declare function remove(options: RemoveOptions): RemoveFileMutation;
+declare function removeDirectory(options: RemoveDirectoryOptions): RemoveDirectoryMutation;
+declare function chmod(options: ChmodOptions): ChmodMutation;
+declare function backup(options: BackupOptions): BackupMutation;
+declare function restoreBackup(options: RestoreBackupOptions): RestoreBackupMutation;
+export declare const fileMutation: {
+    ensureDirectory: typeof ensureDirectory;
+    remove: typeof remove;
+    removeDirectory: typeof removeDirectory;
+    chmod: typeof chmod;
+    backup: typeof backup;
+    restoreBackup: typeof restoreBackup;
+};
+export {};

package/node_modules/@poe-code/config-mutations/dist/mutations/file-mutation.js

@@ -0,0 +1,55 @@
+function ensureDirectory(options) {
+    return {
+        kind: "ensureDirectory",
+        path: options.path,
+        label: options.label
+    };
+}
+function remove(options) {
+    return {
+        kind: "removeFile",
+        target: options.target,
+        whenEmpty: options.whenEmpty,
+        whenContentMatches: options.whenContentMatches,
+        label: options.label
+    };
+}
+function removeDirectory(options) {
+    return {
+        kind: "removeDirectory",
+        path: options.path,
+        force: options.force,
+        label: options.label
+    };
+}
+function chmod(options) {
+    return {
+        kind: "chmod",
+        target: options.target,
+        mode: options.mode,
+        label: options.label
+    };
+}
+function backup(options) {
+    return {
+        kind: "backup",
+        target: options.target,
+        once: options.once,
+        label: options.label
+    };
+}
+function restoreBackup(options) {
+    return {
+        kind: "restoreBackup",
+        target: options.target,
+        label: options.label
+    };
+}
+export const fileMutation = {
+    ensureDirectory,
+    remove,
+    removeDirectory,
+    chmod,
+    backup,
+    restoreBackup
+};

package/node_modules/@poe-code/config-mutations/dist/mutations/template-mutation.d.ts

@@ -0,0 +1,40 @@
+import type { TemplateWriteMutation, TemplateMergeTomlMutation, TemplateMergeJsonMutation, ConfigObject, ValueResolver } from "../types.js";
+export interface WriteOptions {
+    /** Target file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Template ID to load via template loader */
+    templateId: string;
+    /** Context to pass to renderTemplate() */
+    context?: ValueResolver<ConfigObject>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface MergeTomlOptions {
+    /** Target TOML file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Template ID to load via template loader */
+    templateId: string;
+    /** Context to pass to renderTemplate() */
+    context?: ValueResolver<ConfigObject>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface MergeJsonOptions {
+    /** Target JSON file path (must start with ~) */
+    target: ValueResolver<string>;
+    /** Template ID to load via template loader */
+    templateId: string;
+    /** Context to pass to renderTemplate() */
+    context?: ValueResolver<ConfigObject>;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+declare function write(options: WriteOptions): TemplateWriteMutation;
+declare function mergeToml(options: MergeTomlOptions): TemplateMergeTomlMutation;
+declare function mergeJson(options: MergeJsonOptions): TemplateMergeJsonMutation;
+export declare const templateMutation: {
+    write: typeof write;
+    mergeToml: typeof mergeToml;
+    mergeJson: typeof mergeJson;
+};
+export {};

package/node_modules/@poe-code/config-mutations/dist/mutations/template-mutation.js

@@ -0,0 +1,32 @@
+function write(options) {
+    return {
+        kind: "templateWrite",
+        target: options.target,
+        templateId: options.templateId,
+        context: options.context,
+        label: options.label
+    };
+}
+function mergeToml(options) {
+    return {
+        kind: "templateMergeToml",
+        target: options.target,
+        templateId: options.templateId,
+        context: options.context,
+        label: options.label
+    };
+}
+function mergeJson(options) {
+    return {
+        kind: "templateMergeJson",
+        target: options.target,
+        templateId: options.templateId,
+        context: options.context,
+        label: options.label
+    };
+}
+export const templateMutation = {
+    write,
+    mergeToml,
+    mergeJson
+};

package/node_modules/@poe-code/config-mutations/dist/template/render.d.ts

@@ -0,0 +1,6 @@
+export type TemplateVariables = Record<string, string | number | boolean | string[]>;
+/**
+ * Render a mustache template with the given variables.
+ * HTML escaping is disabled.
+ */
+export declare function renderTemplate(template: string, variables: TemplateVariables): string;

package/node_modules/@poe-code/config-mutations/dist/template/render.js

@@ -0,0 +1,8 @@
+import { renderTemplate as renderDesignTemplate } from "toolcraft-design";
+/**
+ * Render a mustache template with the given variables.
+ * HTML escaping is disabled.
+ */
+export function renderTemplate(template, variables) {
+    return renderDesignTemplate(template, variables, { escape: "none" });
+}

package/node_modules/@poe-code/config-mutations/dist/testing/format-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigObject } from "../types.js";
+export declare function parseToml(content: string): ConfigObject;
+export declare function serializeToml(obj: ConfigObject): string;
+export declare function parseJson(content: string): ConfigObject;
+export declare function serializeJson(obj: ConfigObject): string;
+export declare function parseYaml(content: string): ConfigObject;
+export declare function serializeYaml(obj: ConfigObject): string;

package/node_modules/@poe-code/config-mutations/dist/testing/format-utils.js

@@ -0,0 +1,21 @@
+import { jsonFormat } from "../formats/json.js";
+import { tomlFormat } from "../formats/toml.js";
+import { yamlFormat } from "../formats/yaml.js";
+export function parseToml(content) {
+    return tomlFormat.parse(content);
+}
+export function serializeToml(obj) {
+    return tomlFormat.serialize(obj);
+}
+export function parseJson(content) {
+    return jsonFormat.parse(content);
+}
+export function serializeJson(obj) {
+    return jsonFormat.serialize(obj);
+}
+export function parseYaml(content) {
+    return yamlFormat.parse(content);
+}
+export function serializeYaml(obj) {
+    return yamlFormat.serialize(obj);
+}

package/node_modules/@poe-code/config-mutations/dist/testing/index.d.ts

@@ -0,0 +1,3 @@
+export { createMockFs } from "./mock-fs.js";
+export type { MockFileSystem } from "./mock-fs.js";
+export { parseToml, serializeToml, parseJson, serializeJson, parseYaml, serializeYaml } from "./format-utils.js";

package/node_modules/@poe-code/config-mutations/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { createMockFs } from "./mock-fs.js";
+export { parseToml, serializeToml, parseJson, serializeJson, parseYaml, serializeYaml } from "./format-utils.js";

package/node_modules/@poe-code/config-mutations/dist/testing/mock-fs.d.ts

@@ -0,0 +1,25 @@
+import type { FileSystem } from "../types.js";
+export interface MockFileSystem extends FileSystem {
+    /** Current file contents, keyed by absolute path */
+    files: Record<string, string>;
+    /** Created directories */
+    directories: Set<string>;
+    /** Check if a path exists (file or directory) */
+    exists(path: string): boolean;
+    /** Get file content or undefined if not found */
+    getContent(path: string): string | undefined;
+    /** Read file with encoding overloads for compatibility */
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    readFile(path: string): Promise<Buffer>;
+}
+export interface MockFsOptions {
+    /** Initial files - paths can use ~ which will be expanded to homeDir */
+    [path: string]: string;
+}
+/**
+ * Create an in-memory mock filesystem for testing mutations.
+ *
+ * @param initialFiles - Initial files to populate the filesystem with
+ * @param homeDir - Home directory for ~ expansion (defaults to /home/test)
+ */
+export declare function createMockFs(initialFiles?: MockFsOptions, homeDir?: string): MockFileSystem;

package/node_modules/@poe-code/config-mutations/dist/testing/mock-fs.js

@@ -0,0 +1,194 @@
+import path from "node:path";
+const DEFAULT_HOME_DIR = "/home/test";
+/**
+ * Create an in-memory mock filesystem for testing mutations.
+ *
+ * @param initialFiles - Initial files to populate the filesystem with
+ * @param homeDir - Home directory for ~ expansion (defaults to /home/test)
+ */
+export function createMockFs(initialFiles, homeDir = DEFAULT_HOME_DIR) {
+    const files = {};
+    const directories = new Set();
+    // Initialize with provided files
+    if (initialFiles) {
+        for (const [filePath, content] of Object.entries(initialFiles)) {
+            const absolutePath = expandPath(filePath, homeDir);
+            files[absolutePath] = content;
+            // Ensure parent directories exist
+            const parentDir = path.dirname(absolutePath);
+            addDirectoryTree(parentDir, directories);
+        }
+    }
+    // Ensure home directory exists
+    addDirectoryTree(homeDir, directories);
+    const mockFs = {
+        files,
+        directories,
+        exists(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            return absolutePath in files || directories.has(absolutePath);
+        },
+        getContent(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            return files[absolutePath];
+        },
+        async readFile(filePath, encoding) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (!(absolutePath in files)) {
+                const error = new Error(`ENOENT: no such file or directory, open '${absolutePath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            const content = files[absolutePath];
+            if (encoding) {
+                return content;
+            }
+            return Buffer.from(content, "utf8");
+        },
+        async writeFile(filePath, content, options) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (options?.flag === "wx" && absolutePath in files) {
+                const error = new Error(`EEXIST: file already exists, open '${absolutePath}'`);
+                error.code = "EEXIST";
+                throw error;
+            }
+            // Ensure parent directory exists
+            const parentDir = path.dirname(absolutePath);
+            if (!directories.has(parentDir)) {
+                const error = new Error(`ENOENT: no such file or directory, open '${absolutePath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            if (typeof content === "string") {
+                files[absolutePath] = content;
+            }
+            else if (Buffer.isBuffer(content)) {
+                files[absolutePath] = content.toString("utf8");
+            }
+            else {
+                files[absolutePath] = Buffer.from(content.buffer, content.byteOffset, content.byteLength).toString("utf8");
+            }
+        },
+        async mkdir(dirPath, options) {
+            const absolutePath = expandPath(dirPath, homeDir);
+            if (options?.recursive) {
+                addDirectoryTree(absolutePath, directories);
+            }
+            else {
+                // Check parent exists
+                const parentDir = path.dirname(absolutePath);
+                if (parentDir !== absolutePath && !directories.has(parentDir)) {
+                    const error = new Error(`ENOENT: no such file or directory, mkdir '${absolutePath}'`);
+                    error.code = "ENOENT";
+                    throw error;
+                }
+                directories.add(absolutePath);
+            }
+        },
+        async unlink(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (!(absolutePath in files)) {
+                const error = new Error(`ENOENT: no such file or directory, unlink '${absolutePath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            delete files[absolutePath];
+        },
+        async rename(oldPath, newPath) {
+            const absoluteOldPath = expandPath(oldPath, homeDir);
+            const absoluteNewPath = expandPath(newPath, homeDir);
+            if (!(absoluteOldPath in files)) {
+                const error = new Error(`ENOENT: no such file or directory, rename '${absoluteOldPath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            files[absoluteNewPath] = files[absoluteOldPath];
+            delete files[absoluteOldPath];
+        },
+        async stat(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (absolutePath in files) {
+                return { mode: 0o644 };
+            }
+            if (directories.has(absolutePath)) {
+                return { mode: 0o755 };
+            }
+            const error = new Error(`ENOENT: no such file or directory, stat '${absolutePath}'`);
+            error.code = "ENOENT";
+            throw error;
+        },
+        async lstat(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (absolutePath in files || directories.has(absolutePath)) {
+                return { isSymbolicLink: () => false };
+            }
+            const error = new Error(`ENOENT: no such file or directory, lstat '${absolutePath}'`);
+            error.code = "ENOENT";
+            throw error;
+        },
+        async readdir(dirPath) {
+            const absolutePath = expandPath(dirPath, homeDir);
+            if (absolutePath in files) {
+                const error = new Error(`ENOTDIR: not a directory, scandir '${absolutePath}'`);
+                error.code = "ENOTDIR";
+                throw error;
+            }
+            if (!directories.has(absolutePath)) {
+                const error = new Error(`ENOENT: no such file or directory, scandir '${absolutePath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            const entries = new Set();
+            for (const filePath of Object.keys(files)) {
+                if (path.dirname(filePath) === absolutePath) {
+                    entries.add(path.basename(filePath));
+                }
+            }
+            for (const dir of directories) {
+                if (dir !== absolutePath && path.dirname(dir) === absolutePath) {
+                    entries.add(path.basename(dir));
+                }
+            }
+            return Array.from(entries);
+        },
+        async chmod(filePath, mode) {
+            void mode; // In mock fs, we don't actually store mode changes
+            const absolutePath = expandPath(filePath, homeDir);
+            if (!(absolutePath in files) && !directories.has(absolutePath)) {
+                const error = new Error(`ENOENT: no such file or directory, chmod '${absolutePath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            // Mode change is a no-op in mock fs but we don't throw
+        }
+    };
+    return mockFs;
+}
+/**
+ * Expand ~ to homeDir in a path.
+ */
+function expandPath(inputPath, homeDir) {
+    if (inputPath.startsWith("~/")) {
+        return path.join(homeDir, inputPath.slice(2));
+    }
+    if (inputPath === "~") {
+        return homeDir;
+    }
+    if (inputPath.startsWith("~")) {
+        // ~something (not ~/) - treat as relative path from home
+        return path.join(homeDir, inputPath.slice(1));
+    }
+    return inputPath;
+}
+/**
+ * Add a directory and all its parent directories to the set.
+ */
+function addDirectoryTree(dirPath, directories) {
+    const parts = dirPath.split(path.sep).filter(Boolean);
+    let current = "/";
+    directories.add(current);
+    for (const part of parts) {
+        current = path.join(current, part);
+        directories.add(current);
+    }
+}