toolcraft 0.0.5 → 0.0.7

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

@@ -0,0 +1,49 @@
+import { jsonFormat } from "./json.js";
+import { tomlFormat } from "./toml.js";
+import { yamlFormat } from "./yaml.js";
+const formatRegistry = {
+    json: jsonFormat,
+    toml: tomlFormat,
+    yaml: yamlFormat
+};
+const extensionMap = {
+    ".json": "json",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml"
+};
+/**
+ * Get a format handler by path (auto-detect from extension) or explicit format name.
+ */
+export function getConfigFormat(pathOrFormat) {
+    // Check if it's an explicit format name
+    if (pathOrFormat in formatRegistry) {
+        return formatRegistry[pathOrFormat];
+    }
+    // Try to detect from extension
+    const ext = getExtension(pathOrFormat);
+    const formatName = extensionMap[ext];
+    if (!formatName) {
+        throw new Error(`Unsupported config format. Cannot detect format from "${pathOrFormat}". ` +
+            `Supported extensions: ${Object.keys(extensionMap).join(", ")}. ` +
+            `Supported format names: ${Object.keys(formatRegistry).join(", ")}.`);
+    }
+    return formatRegistry[formatName];
+}
+/**
+ * Detect format name from a file path.
+ */
+export function detectFormat(path) {
+    const ext = getExtension(path);
+    return extensionMap[ext];
+}
+function getExtension(path) {
+    const lastDot = path.lastIndexOf(".");
+    if (lastDot === -1) {
+        return "";
+    }
+    return path.slice(lastDot).toLowerCase();
+}
+export { jsonFormat } from "./json.js";
+export { tomlFormat } from "./toml.js";
+export { yamlFormat } from "./yaml.js";

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

@@ -0,0 +1,31 @@
+import type { ConfigFormat, ConfigObject, ConfigValue } from "../types.js";
+declare function detectIndent(content: string): string;
+/**
+ * Modify JSON content at a specific path while preserving comments and formatting.
+ * Uses jsonc-parser's modify() for targeted updates.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param path - JSON path array, e.g. ["mcpServers", "my-server"]
+ * @param value - The value to set (or undefined to remove)
+ * @returns The modified JSON content with comments preserved
+ */
+declare function modifyAtPath(content: string, path: (string | number)[], value: ConfigValue | undefined): string;
+/**
+ * Merge a patch into JSON content while preserving comments and formatting.
+ * Uses jsonc.modify() for each top-level key to preserve existing comments.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param patch - Object with values to merge
+ * @returns The modified JSON content with comments preserved
+ */
+declare function mergePreservingComments(content: string, patch: ConfigObject): string;
+/**
+ * Remove a key from JSON content while preserving comments and formatting.
+ *
+ * @param content - The original JSON content
+ * @param path - JSON path array to the key to remove
+ * @returns The modified JSON content with comments preserved
+ */
+declare function removeAtPath(content: string, path: (string | number)[]): string;
+export { detectIndent, modifyAtPath, mergePreservingComments, removeAtPath };
+export declare const jsonFormat: ConfigFormat;

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

@@ -0,0 +1,140 @@
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectIndent(content) {
+    const match = content.match(/^[\t ]+/m);
+    if (match) {
+        return match[0];
+    }
+    return "  ";
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const errors = [];
+    const parsed = jsonc.parse(content, errors, {
+        allowTrailingComma: true,
+        disallowComments: false
+    });
+    if (errors.length > 0) {
+        throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+    }
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected JSON object.");
+    }
+    return parsed;
+}
+function serialize(obj) {
+    return `${JSON.stringify(obj, null, 2)}\n`;
+}
+function merge(base, patch) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = result[key];
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            result[key] = merge(existing, value);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = { ...obj };
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!(key in result)) {
+            continue;
+        }
+        const current = result[key];
+        // Empty object pattern means "delete this key entirely"
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        // Non-empty object pattern with object current: recurse
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                result[key] = childResult;
+            }
+            continue;
+        }
+        delete result[key];
+        changed = true;
+    }
+    return { changed, result };
+}
+/**
+ * Modify JSON content at a specific path while preserving comments and formatting.
+ * Uses jsonc-parser's modify() for targeted updates.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param path - JSON path array, e.g. ["mcpServers", "my-server"]
+ * @param value - The value to set (or undefined to remove)
+ * @returns The modified JSON content with comments preserved
+ */
+function modifyAtPath(content, path, value) {
+    const indent = detectIndent(content);
+    const formattingOptions = {
+        tabSize: indent === "\t" ? 1 : indent.length,
+        insertSpaces: indent !== "\t",
+        eol: "\n"
+    };
+    const edits = jsonc.modify(content, path, value, { formattingOptions });
+    let result = jsonc.applyEdits(content, edits);
+    if (!result.endsWith("\n")) {
+        result += "\n";
+    }
+    return result;
+}
+/**
+ * Merge a patch into JSON content while preserving comments and formatting.
+ * Uses jsonc.modify() for each top-level key to preserve existing comments.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param patch - Object with values to merge
+ * @returns The modified JSON content with comments preserved
+ */
+function mergePreservingComments(content, patch) {
+    let result = content || "{}";
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        result = modifyAtPath(result, [key], value);
+    }
+    return result;
+}
+/**
+ * Remove a key from JSON content while preserving comments and formatting.
+ *
+ * @param content - The original JSON content
+ * @param path - JSON path array to the key to remove
+ * @returns The modified JSON content with comments preserved
+ */
+function removeAtPath(content, path) {
+    return modifyAtPath(content, path, undefined);
+}
+export { detectIndent, modifyAtPath, mergePreservingComments, removeAtPath };
+export const jsonFormat = {
+    parse,
+    serialize,
+    merge,
+    prune
+};

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

@@ -0,0 +1,2 @@
+import type { ConfigFormat } from "../types.js";
+export declare const tomlFormat: ConfigFormat;

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

@@ -0,0 +1,72 @@
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const parsed = parseToml(content);
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected TOML document to be a table.");
+    }
+    return parsed;
+}
+function serialize(obj) {
+    const serialized = stringifyToml(obj);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+function merge(base, patch) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = result[key];
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            result[key] = merge(existing, value);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = { ...obj };
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!(key in result)) {
+            continue;
+        }
+        const current = result[key];
+        // Empty object pattern means "delete this key entirely"
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        // Non-empty object pattern with object current: recurse
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                result[key] = childResult;
+            }
+            continue;
+        }
+        delete result[key];
+        changed = true;
+    }
+    return { changed, result };
+}
+export const tomlFormat = {
+    parse,
+    serialize,
+    merge,
+    prune
+};

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

@@ -0,0 +1,2 @@
+import type { ConfigFormat } from "../types.js";
+export declare const yamlFormat: ConfigFormat;

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

@@ -0,0 +1,73 @@
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const parsed = parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected YAML object.");
+    }
+    return parsed;
+}
+function serialize(obj) {
+    const serialized = stringifyYaml(obj);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+function merge(base, patch) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = result[key];
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            result[key] = merge(existing, value);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = { ...obj };
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!(key in result)) {
+            continue;
+        }
+        const current = result[key];
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                result[key] = childResult;
+            }
+            continue;
+        }
+        delete result[key];
+        changed = true;
+    }
+    return { changed, result };
+}
+export const yamlFormat = {
+    parse,
+    serialize,
+    merge,
+    prune
+};

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

@@ -0,0 +1,18 @@
+import type { FileSystem } from "./types.js";
+/**
+ * Check if an error is a "file not found" (ENOENT) error.
+ */
+export declare function isNotFound(error: unknown): boolean;
+/**
+ * Read a file if it exists, returning null if not found.
+ */
+export declare function readFileIfExists(fs: FileSystem, target: string): Promise<string | null>;
+/**
+ * Check if a path exists (file or directory).
+ */
+export declare function pathExists(fs: FileSystem, target: string): Promise<boolean>;
+/**
+ * Create an ISO timestamp safe for use in filenames.
+ * Replaces colons and dots with dashes.
+ */
+export declare function createTimestamp(): string;

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

@@ -0,0 +1,45 @@
+/**
+ * Check if an error is a "file not found" (ENOENT) error.
+ */
+export function isNotFound(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+/**
+ * Read a file if it exists, returning null if not found.
+ */
+export async function readFileIfExists(fs, target) {
+    try {
+        return await fs.readFile(target, "utf8");
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Check if a path exists (file or directory).
+ */
+export async function pathExists(fs, target) {
+    try {
+        await fs.stat(target);
+        return true;
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Create an ISO timestamp safe for use in filenames.
+ * Replaces colons and dots with dashes.
+ */
+export function createTimestamp() {
+    return new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}

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

@@ -0,0 +1,8 @@
+export { configMutation } from "./mutations/config-mutation.js";
+export { fileMutation } from "./mutations/file-mutation.js";
+export { templateMutation } from "./mutations/template-mutation.js";
+export { runMutations } from "./execution/run-mutations.js";
+export { renderTemplate, type TemplateVariables } from "./template/render.js";
+export { isNotFound, readFileIfExists, pathExists, createTimestamp } from "./fs-utils.js";
+export type { ConfigObject, ConfigValue, Mutation, MutationContext, MutationResult, MutationObservers, MutationDetails, MutationOutcome, FileSystem, TemplateLoader, ConfigFormat, PathMapper } from "./types.js";
+export { isConfigObject } from "./types.js";

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

@@ -0,0 +1,8 @@
+// Main exports
+export { configMutation } from "./mutations/config-mutation.js";
+export { fileMutation } from "./mutations/file-mutation.js";
+export { templateMutation } from "./mutations/template-mutation.js";
+export { runMutations } from "./execution/run-mutations.js";
+export { renderTemplate } from "./template/render.js";
+export { isNotFound, readFileIfExists, pathExists, createTimestamp } from "./fs-utils.js";
+export { isConfigObject } from "./types.js";

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,52 @@
+import type { EnsureDirectoryMutation, RemoveDirectoryMutation, RemoveFileMutation, ChmodMutation, BackupMutation, 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>;
+    /** 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;
+export declare const fileMutation: {
+    ensureDirectory: typeof ensureDirectory;
+    remove: typeof remove;
+    removeDirectory: typeof removeDirectory;
+    chmod: typeof chmod;
+    backup: typeof backup;
+};
+export {};

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

@@ -0,0 +1,46 @@
+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,
+        label: options.label
+    };
+}
+export const fileMutation = {
+    ensureDirectory,
+    remove,
+    removeDirectory,
+    chmod,
+    backup
+};

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 Mustache.render() */
+    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 Mustache.render() */
+    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 Mustache.render() */
+    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 {};