terminal-pilot 0.0.30 → 0.0.32

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

@@ -0,0 +1,168 @@
+export type ConfigPrimitive = string | number | boolean | null;
+export type ConfigValue = ConfigPrimitive | ConfigObject | ConfigArray | Date;
+export interface ConfigObject {
+    [key: string]: ConfigValue;
+}
+export type ConfigArray = ConfigValue[];
+export declare function isConfigObject(value: unknown): value is ConfigObject;
+export interface FileSystem {
+    readFile(path: string, encoding: "utf8"): Promise<string>;
+    writeFile(path: string, content: string, options?: {
+        encoding: "utf8";
+        flag?: string;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive: boolean;
+    }): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    rm?(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    stat(path: string): Promise<{
+        mode?: number;
+    }>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    readdir(path: string): Promise<string[]>;
+    chmod?(path: string, mode: number): Promise<void>;
+}
+export type TemplateLoader = (templateId: string) => Promise<string>;
+export interface ConfigFormat {
+    /** Parse string content into object */
+    parse(content: string): ConfigObject;
+    /** Serialize object to string (with consistent formatting) */
+    serialize(obj: ConfigObject): string;
+    /** Serialize an update against original content while preserving comments when possible */
+    serializeUpdate?(content: string, current: ConfigObject, next: ConfigObject): string;
+    /** Deep merge patch into base, returning new object */
+    merge(base: ConfigObject, patch: ConfigObject): ConfigObject;
+    /** Remove keys matching shape from object, returning new object */
+    prune(obj: ConfigObject, shape: ConfigObject): {
+        changed: boolean;
+        result: ConfigObject;
+    };
+}
+export interface PathMapper {
+    /** Map a target directory to a different location (e.g., for isolated configs) */
+    mapTargetDirectory(input: {
+        targetDirectory: string;
+    }): string;
+}
+export interface MutationContext {
+    /** Filesystem interface - required */
+    fs: FileSystem;
+    /** Home directory for ~ expansion - required */
+    homeDir: string;
+    /** Optional dry-run mode */
+    dryRun?: boolean;
+    /** Optional observers for logging */
+    observers?: MutationObservers;
+    /** Required for template mutations */
+    templates?: TemplateLoader;
+    /** Optional path mapper for redirecting paths (used for isolated configs) */
+    pathMapper?: PathMapper;
+}
+export interface MutationOptions {
+    [key: string]: unknown;
+}
+export type ValueResolver<T> = T | ((ctx: MutationOptions) => T);
+interface BaseMutation {
+    /** Human-readable label for logging */
+    label?: string;
+}
+export interface ConfigMergeMutation extends BaseMutation {
+    kind: "configMerge";
+    target: ValueResolver<string>;
+    value: ValueResolver<ConfigObject>;
+    format?: "json" | "toml" | "yaml";
+    pruneByPrefix?: Record<string, string>;
+}
+export interface ConfigPruneMutation extends BaseMutation {
+    kind: "configPrune";
+    target: ValueResolver<string>;
+    shape: ValueResolver<ConfigObject>;
+    format?: "json" | "toml" | "yaml";
+    onlyIf?: (doc: ConfigObject, ctx: MutationOptions) => boolean;
+}
+export interface ConfigTransformMutation extends BaseMutation {
+    kind: "configTransform";
+    target: ValueResolver<string>;
+    format?: "json" | "toml" | "yaml";
+    transform: (content: ConfigObject, ctx: MutationOptions) => {
+        content: ConfigObject | null;
+        changed: boolean;
+    };
+}
+export interface EnsureDirectoryMutation extends BaseMutation {
+    kind: "ensureDirectory";
+    path: ValueResolver<string>;
+}
+export interface RemoveDirectoryMutation extends BaseMutation {
+    kind: "removeDirectory";
+    path: ValueResolver<string>;
+    force?: boolean;
+}
+export interface RemoveFileMutation extends BaseMutation {
+    kind: "removeFile";
+    target: ValueResolver<string>;
+    whenEmpty?: boolean;
+    whenContentMatches?: RegExp;
+}
+export interface ChmodMutation extends BaseMutation {
+    kind: "chmod";
+    target: ValueResolver<string>;
+    mode: number;
+}
+export interface BackupMutation extends BaseMutation {
+    kind: "backup";
+    target: ValueResolver<string>;
+    once?: boolean;
+}
+export interface RestoreBackupMutation extends BaseMutation {
+    kind: "restoreBackup";
+    target: ValueResolver<string>;
+}
+export interface TemplateWriteMutation extends BaseMutation {
+    kind: "templateWrite";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export interface TemplateMergeTomlMutation extends BaseMutation {
+    kind: "templateMergeToml";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export interface TemplateMergeJsonMutation extends BaseMutation {
+    kind: "templateMergeJson";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export type Mutation = ConfigMergeMutation | ConfigPruneMutation | ConfigTransformMutation | EnsureDirectoryMutation | RemoveDirectoryMutation | RemoveFileMutation | ChmodMutation | BackupMutation | RestoreBackupMutation | TemplateWriteMutation | TemplateMergeTomlMutation | TemplateMergeJsonMutation;
+export type MutationEffect = "none" | "mkdir" | "write" | "delete" | "chmod" | "copy";
+export type MutationDetail = "create" | "update" | "delete" | "noop" | "backup" | "restore";
+export interface MutationOutcome {
+    changed: boolean;
+    effect: MutationEffect;
+    detail?: MutationDetail;
+}
+export interface MutationDetails {
+    kind: string;
+    label: string;
+    targetPath?: string;
+}
+export interface MutationObservers {
+    onStart?(details: MutationDetails): void;
+    onComplete?(details: MutationDetails, outcome: MutationOutcome): void;
+    onError?(details: MutationDetails, error: unknown): void;
+}
+export interface MutationResult {
+    changed: boolean;
+    effects: MutationOutcome[];
+}
+export {};

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

@@ -0,0 +1,6 @@
+// ============================================================================
+// Config Object Types
+// ============================================================================
+export function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@poe-code/config-mutations/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@poe-code/config-mutations",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.3.0",
+    "yaml": "^2.8.1"
+  }
+}

package/node_modules/@poe-code/frontmatter/README.md

@@ -0,0 +1,35 @@
+# @poe-code/frontmatter
+
+Shared YAML frontmatter parsing for poe-code packages.
+
+## API
+
+```ts
+import {
+  FrontmatterParseError,
+  parseFrontmatter,
+  parseFrontmatterDocument,
+  stringifyFrontmatter
+} from "@poe-code/frontmatter";
+```
+
+- `parseFrontmatter(source)` returns `{ frontmatter, body }`.
+- `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
+- `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
+- `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+
+When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
+The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.
+YAML mappings that contain `__proto__` keep it as an own property without changing the object's prototype.
+
+Duplicate mapping keys use YAML's last-wins behavior by default, matching the
+legacy frontmatter readers. Callers that need strict YAML mappings can pass
+`{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
+
+## Environment
+
+This package reads no environment variables.
+
+## Config
+
+This package has no configuration options.

package/node_modules/@poe-code/frontmatter/dist/fences.d.ts

@@ -0,0 +1,25 @@
+export type FrontmatterBlock = {
+    raw: string;
+    body: string;
+    rawStart: number;
+    rawEnd: number;
+};
+export type SplitFrontmatterResult = FrontmatterBlock | {
+    body: string;
+};
+export type InspectFrontmatterResult = (FrontmatterBlock & {
+    kind: "frontmatter";
+}) | {
+    kind: "missing-closing-fence";
+    raw: string;
+    rawStart: number;
+    rawEnd: number;
+    body: "";
+    message: string;
+    position: number;
+} | {
+    kind: "body";
+    body: string;
+};
+export declare function splitFrontmatterBlock(source: string): SplitFrontmatterResult;
+export declare function inspectFrontmatterBlock(source: string): InspectFrontmatterResult;

package/node_modules/@poe-code/frontmatter/dist/fences.js

@@ -0,0 +1,100 @@
+const MISSING_END_DELIMITER_MESSAGE = "Missing YAML frontmatter end delimiter (---).";
+export function splitFrontmatterBlock(source) {
+    const inspected = inspectFrontmatterBlock(source);
+    if (inspected.kind === "body") {
+        return { body: inspected.body };
+    }
+    if (inspected.kind === "missing-closing-fence") {
+        throw new Error(inspected.message);
+    }
+    return {
+        raw: inspected.raw,
+        rawStart: inspected.rawStart,
+        rawEnd: inspected.rawEnd,
+        body: inspected.body
+    };
+}
+export function inspectFrontmatterBlock(source) {
+    const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    const sourceOffset = source.length - content.length;
+    const opening = readOpeningFence(content);
+    if (opening === undefined) {
+        return { kind: "body", body: source };
+    }
+    const closing = findClosingFence(content, opening.next);
+    if (closing === undefined) {
+        return {
+            kind: "missing-closing-fence",
+            raw: content.slice(opening.next),
+            rawStart: sourceOffset + opening.next,
+            rawEnd: source.length,
+            body: "",
+            message: MISSING_END_DELIMITER_MESSAGE,
+            position: source.length
+        };
+    }
+    return {
+        kind: "frontmatter",
+        raw: content.slice(opening.next, closing.index),
+        rawStart: sourceOffset + opening.next,
+        rawEnd: sourceOffset + closing.index,
+        body: content.slice(closing.end + closing.lineBreakLength)
+    };
+}
+function readOpeningFence(source) {
+    if (!source.startsWith("---")) {
+        return undefined;
+    }
+    const lineEnd = findLineEnd(source, 0);
+    if (lineEnd.lineBreakLength === 0 || !isFenceLine(source.slice(0, lineEnd.index))) {
+        return undefined;
+    }
+    return { next: lineEnd.index + lineEnd.lineBreakLength };
+}
+function findClosingFence(source, start) {
+    let lineStart = start;
+    while (lineStart <= source.length) {
+        const lineEnd = findLineEnd(source, lineStart);
+        if (isFenceLine(source.slice(lineStart, lineEnd.index))) {
+            return {
+                index: lineStart,
+                end: lineEnd.index,
+                lineBreakLength: lineEnd.lineBreakLength
+            };
+        }
+        if (lineEnd.lineBreakLength === 0) {
+            break;
+        }
+        lineStart = lineEnd.index + lineEnd.lineBreakLength;
+    }
+    return undefined;
+}
+function isFenceLine(line) {
+    if (!line.startsWith("---")) {
+        return false;
+    }
+    for (let index = 3; index < line.length; index += 1) {
+        const character = line[index];
+        if (character !== " " && character !== "\t") {
+            return false;
+        }
+    }
+    return true;
+}
+function findLineEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\n") {
+            return { index, lineBreakLength: 1 };
+        }
+        if (character === "\r") {
+            return {
+                index,
+                lineBreakLength: source[index + 1] === "\n" ? 2 : 1
+            };
+        }
+        index += 1;
+    }
+    return { index: source.length, lineBreakLength: 0 };
+}

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -0,0 +1,20 @@
+import { LineCounter } from "yaml";
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedFrontmatterDocument extends ParsedFrontmatter {
+    errors: readonly {
+        message: string;
+        pos?: [number, number];
+    }[];
+    lineCounter: LineCounter;
+}
+export interface ParseFrontmatterOptions {
+    uniqueKeys?: boolean;
+}
+export declare class FrontmatterParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
+export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;

package/node_modules/@poe-code/frontmatter/dist/parse.js

@@ -0,0 +1,209 @@
+import { LineCounter, parse, parseDocument } from "yaml";
+import { inspectFrontmatterBlock, splitFrontmatterBlock } from "./fences.js";
+export class FrontmatterParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FrontmatterParseError";
+    }
+}
+export function parseFrontmatter(source, options = {}) {
+    const split = splitFrontmatter(source);
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body
+        };
+    }
+    return {
+        frontmatter: parseYamlFrontmatter(split.raw, options),
+        body: split.body
+    };
+}
+export function parseFrontmatterDocument(source, options = {}) {
+    const split = inspectFrontmatterBlock(source);
+    const lineCounter = createSourceLineCounter(source);
+    if (split.kind === "body") {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors: [],
+            lineCounter
+        };
+    }
+    if (split.kind === "missing-closing-fence") {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors: [{ message: split.message, pos: [split.position, split.position] }],
+            lineCounter
+        };
+    }
+    const yamlLineCounter = new LineCounter();
+    const normalizedYaml = normalizeYamlLineEndings(split.raw);
+    const document = parseDocument(normalizedYaml, {
+        lineCounter: yamlLineCounter,
+        prettyErrors: false,
+        uniqueKeys: options.uniqueKeys ?? false
+    });
+    const errors = document.errors.map((error) => ({
+        message: error.message,
+        ...(error.pos === undefined
+            ? {}
+            : { pos: translateYamlErrorPosition(error.pos, split) })
+    }));
+    if (errors.length > 0) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors,
+            lineCounter
+        };
+    }
+    try {
+        return {
+            frontmatter: normalizeYamlFrontmatter(document.toJSON()),
+            body: split.body,
+            errors,
+            lineCounter
+        };
+    }
+    catch (error) {
+        if (error instanceof FrontmatterParseError) {
+            return {
+                frontmatter: {},
+                body: split.body,
+                errors: [{ message: error.message }],
+                lineCounter
+            };
+        }
+        throw error;
+    }
+}
+function createSourceLineCounter(source) {
+    const lineCounter = new LineCounter();
+    lineCounter.addNewLine(0);
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === "\n") {
+            lineCounter.addNewLine(index + 1);
+            continue;
+        }
+        if (character === "\r") {
+            lineCounter.addNewLine(index + (source[index + 1] === "\n" ? 2 : 1));
+            if (source[index + 1] === "\n") {
+                index += 1;
+            }
+        }
+    }
+    return lineCounter;
+}
+function translateYamlErrorPosition(pos, split) {
+    return pos.map((offset) => split.rawStart + normalizeYamlErrorOffset(split.raw, offset));
+}
+function normalizeYamlErrorOffset(raw, offset) {
+    if (offset >= raw.length && endsWithLineBreak(raw)) {
+        return findPreviousLineStart(raw, raw.length);
+    }
+    return offset;
+}
+function endsWithLineBreak(value) {
+    return value.endsWith("\n") || value.endsWith("\r");
+}
+function findPreviousLineStart(value, end) {
+    let index = end - 1;
+    if (value[index] === "\n") {
+        index -= 1;
+    }
+    if (value[index] === "\r") {
+        index -= 1;
+    }
+    while (index >= 0) {
+        const character = value[index];
+        if (character === "\n" || character === "\r") {
+            return index + 1;
+        }
+        index -= 1;
+    }
+    return 0;
+}
+function splitFrontmatter(source) {
+    try {
+        return splitFrontmatterBlock(source);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new FrontmatterParseError(error.message);
+        }
+        throw error;
+    }
+}
+function parseYamlFrontmatter(yamlBlock, options) {
+    let parsed;
+    try {
+        parsed = parse(normalizeYamlLineEndings(yamlBlock), {
+            uniqueKeys: options.uniqueKeys ?? false
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+    return normalizeYamlFrontmatter(parsed);
+}
+function normalizeYamlLineEndings(value) {
+    if (!value.includes("\r")) {
+        return value;
+    }
+    let normalized = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== "\r") {
+            normalized += character;
+            continue;
+        }
+        if (value[index + 1] === "\n") {
+            normalized += "\r\n";
+            index += 1;
+            continue;
+        }
+        normalized += "\n";
+    }
+    return normalized;
+}
+function normalizeYamlFrontmatter(value) {
+    if (value === null || value === undefined) {
+        return {};
+    }
+    if (!isPlainRecord(value)) {
+        throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
+    }
+    return normalizeYamlValue(value);
+}
+function normalizeYamlValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeYamlValue(item));
+    }
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            value: normalizeYamlValue(entryValue),
+            writable: true
+        });
+    }
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/node_modules/@poe-code/frontmatter/dist/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringifyFrontmatter(frontmatter: Record<string, unknown>, body: string): string;

package/node_modules/@poe-code/frontmatter/dist/stringify.js

@@ -0,0 +1,48 @@
+import { stringify } from "yaml";
+import { FrontmatterParseError } from "./parse.js";
+export function stringifyFrontmatter(frontmatter, body) {
+    try {
+        assertFrontmatterRoot(frontmatter);
+        assertAcyclic(frontmatter);
+        return `---\n${stringify(frontmatter, { aliasDuplicateObjects: false }).trimEnd()}\n---\n${body}`;
+    }
+    catch (error) {
+        if (error instanceof FrontmatterParseError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : "Unknown YAML stringify error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+}
+function assertFrontmatterRoot(value) {
+    if (!isPlainRecord(value)) {
+        throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
+    }
+}
+function assertAcyclic(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null) {
+        return;
+    }
+    if (seen.has(value)) {
+        throw new FrontmatterParseError("Cannot stringify cyclic frontmatter.");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertAcyclic(item, seen);
+        }
+    }
+    else {
+        for (const item of Object.values(value)) {
+            assertAcyclic(item, seen);
+        }
+    }
+    seen.delete(value);
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/node_modules/@poe-code/frontmatter/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/frontmatter",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test": "cd ../.. && vitest run packages/frontmatter/src",
+    "test:unit": "cd ../.. && vitest run packages/frontmatter/src"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}