@zincapp/znvault-cli 2.18.1 → 2.19.0

package/dist/commands/secret/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/secret/index.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8BzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgB7D;AAGD,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/secret/index.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+BzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB7D;AAGD,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dist/commands/secret/index.js

@@ -8,6 +8,7 @@ import { registerDeleteCommand } from './delete.js';
 import { registerRotateCommand } from './rotate.js';
 import { registerHistoryCommand } from './history.js';
 import { registerCopyCommand } from './copy.js';
+import { registerPatchCommand } from './patch.js';
 // Help text for secret identifier format
 const SECRET_ID_HELP = `
 Secret Identifier Formats:
@@ -41,6 +42,7 @@ export function registerSecretCommands(program) {
     registerRotateCommand(secretCmd);
     registerHistoryCommand(secretCmd);
     registerCopyCommand(secretCmd);
+    registerPatchCommand(secretCmd);
 }
 // Re-export types for external use
 export * from './types.js';

package/dist/commands/secret/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/secret/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AAUrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD,yCAAyC;AACzC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;CAgBtB,CAAC;AAEF,MAAM,UAAU,sBAAsB,CAAC,OAAgB;IACrD,MAAM,SAAS,GAAG,OAAO;SACtB,OAAO,CAAC,QAAQ,CAAC;SACjB,WAAW,CAAC,gBAAgB,CAAC;SAC7B,WAAW,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAExC,2BAA2B;IAC3B,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC/B,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC9B,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClC,mBAAmB,CAAC,SAAS,CAAC,CAAC;AACjC,CAAC;AAED,mCAAmC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/secret/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AAUrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,yCAAyC;AACzC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;CAgBtB,CAAC;AAEF,MAAM,UAAU,sBAAsB,CAAC,OAAgB;IACrD,MAAM,SAAS,GAAG,OAAO;SACtB,OAAO,CAAC,QAAQ,CAAC;SACjB,WAAW,CAAC,gBAAgB,CAAC;SAC7B,WAAW,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAExC,2BAA2B;IAC3B,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC/B,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC9B,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACjC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClC,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC/B,oBAAoB,CAAC,SAAS,CAAC,CAAC;AAClC,CAAC;AAED,mCAAmC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dist/commands/secret/patch/diff.d.ts

@@ -0,0 +1,14 @@
+import type { DiffResult, AppliedOperation } from './types.js';
+/**
+ * Generate a diff between two serialized values
+ */
+export declare function generateDiff(before: string, after: string, operations: AppliedOperation[]): DiffResult;
+/**
+ * Display a diff result
+ */
+export declare function displayDiff(diff: DiffResult): void;
+/**
+ * Display a summary of operations to be applied
+ */
+export declare function displayOperationsSummary(operations: AppliedOperation[]): void;
+//# sourceMappingURL=diff.d.ts.map

package/dist/commands/secret/patch/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../src/commands/secret/patch/diff.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAc,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAO3E;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,gBAAgB,EAAE,GAC7B,UAAU,CA0BZ;AA8CD;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAuClD;AAsDD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAyB7E"}

package/dist/commands/secret/patch/diff.js

@@ -0,0 +1,181 @@
+// Path: src/commands/secret/patch/diff.ts
+/**
+ * Diff generation for dry-run mode
+ */
+import chalk from 'chalk';
+import { isPlainMode } from '../../../lib/output-mode.js';
+// ============================================================================
+// Diff Generation
+// ============================================================================
+/**
+ * Generate a diff between two serialized values
+ */
+export function generateDiff(before, after, operations) {
+    const changes = operations.map(op => {
+        if (op.type === 'set') {
+            if (op.previousValue === undefined) {
+                return {
+                    type: 'add',
+                    path: op.path,
+                    newValue: op.newValue,
+                };
+            }
+            return {
+                type: 'modify',
+                path: op.path,
+                oldValue: op.previousValue,
+                newValue: op.newValue,
+            };
+        }
+        else {
+            return {
+                type: 'remove',
+                path: op.path,
+                oldValue: op.previousValue,
+            };
+        }
+    });
+    return { before, after, changes };
+}
+// ============================================================================
+// Diff Display
+// ============================================================================
+/**
+ * Format a diff change for display
+ */
+function formatChange(change, plain) {
+    const formatValue = (val) => {
+        if (val === undefined)
+            return 'undefined';
+        if (val === null)
+            return 'null';
+        if (typeof val === 'string')
+            return `"${val}"`;
+        if (typeof val === 'object')
+            return JSON.stringify(val);
+        if (typeof val === 'number' || typeof val === 'boolean')
+            return String(val);
+        // For bigint, symbol, or other types
+        return JSON.stringify(val);
+    };
+    switch (change.type) {
+        case 'add':
+            if (plain) {
+                return `+ ${change.path} = ${formatValue(change.newValue)}`;
+            }
+            return chalk.green(`+ ${change.path} = ${formatValue(change.newValue)}`);
+        case 'remove':
+            if (plain) {
+                return `- ${change.path} = ${formatValue(change.oldValue)}`;
+            }
+            return chalk.red(`- ${change.path} = ${formatValue(change.oldValue)}`);
+        case 'modify':
+            if (plain) {
+                return `~ ${change.path}: ${formatValue(change.oldValue)} -> ${formatValue(change.newValue)}`;
+            }
+            return chalk.yellow(`~ ${change.path}: ` +
+                chalk.red(formatValue(change.oldValue)) +
+                chalk.gray(' -> ') +
+                chalk.green(formatValue(change.newValue)));
+    }
+}
+/**
+ * Display a diff result
+ */
+export function displayDiff(diff) {
+    const plain = isPlainMode();
+    console.log();
+    if (plain) {
+        console.log('=== Changes to be applied ===');
+    }
+    else {
+        console.log(chalk.bold.cyan('Changes to be applied:'));
+    }
+    console.log();
+    if (diff.changes.length === 0) {
+        if (plain) {
+            console.log('No changes detected');
+        }
+        else {
+            console.log(chalk.dim('No changes detected'));
+        }
+        return;
+    }
+    for (const change of diff.changes) {
+        console.log('  ' + formatChange(change, plain));
+    }
+    console.log();
+    if (plain) {
+        console.log('=== Before ===');
+    }
+    else {
+        console.log(chalk.bold.dim('Before:'));
+    }
+    displayWithHighlight(diff.before, 'remove', plain);
+    console.log();
+    if (plain) {
+        console.log('=== After ===');
+    }
+    else {
+        console.log(chalk.bold.dim('After:'));
+    }
+    displayWithHighlight(diff.after, 'add', plain);
+}
+/**
+ * Display content with syntax highlighting
+ */
+function displayWithHighlight(content, _type, plain) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (plain) {
+            console.log(`  ${line}`);
+        }
+        else {
+            // Simple syntax highlighting
+            let highlighted = line;
+            // Highlight keys
+            highlighted = highlighted.replace(/^(\s*)("?[a-zA-Z_][a-zA-Z0-9_-]*"?)\s*:/, `$1${chalk.cyan('$2')}:`);
+            // Highlight string values
+            highlighted = highlighted.replace(/:\s*("(?:[^"\\]|\\.)*")/g, `: ${chalk.green('$1')}`);
+            // Highlight numbers
+            highlighted = highlighted.replace(/:\s*(-?\d+\.?\d*)/g, `: ${chalk.yellow('$1')}`);
+            // Highlight booleans
+            highlighted = highlighted.replace(/:\s*(true|false)/g, `: ${chalk.magenta('$1')}`);
+            // Highlight null
+            highlighted = highlighted.replace(/:\s*(null)/g, `: ${chalk.dim('$1')}`);
+            console.log(`  ${highlighted}`);
+        }
+    }
+}
+// ============================================================================
+// Summary Display
+// ============================================================================
+/**
+ * Display a summary of operations to be applied
+ */
+export function displayOperationsSummary(operations) {
+    const plain = isPlainMode();
+    const adds = operations.filter(o => o.type === 'set' && o.previousValue === undefined).length;
+    const modifies = operations.filter(o => o.type === 'set' && o.previousValue !== undefined).length;
+    const removes = operations.filter(o => o.type === 'unset').length;
+    const parts = [];
+    if (adds > 0) {
+        parts.push(plain ? `${adds} add` : chalk.green(`${adds} add`));
+    }
+    if (modifies > 0) {
+        parts.push(plain ? `${modifies} modify` : chalk.yellow(`${modifies} modify`));
+    }
+    if (removes > 0) {
+        parts.push(plain ? `${removes} remove` : chalk.red(`${removes} remove`));
+    }
+    if (parts.length > 0) {
+        console.log();
+        if (plain) {
+            console.log(`Summary: ${parts.join(', ')}`);
+        }
+        else {
+            console.log(chalk.dim('Summary: ') + parts.join(chalk.dim(', ')));
+        }
+    }
+}
+//# sourceMappingURL=diff.js.map

package/dist/commands/secret/patch/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../../src/commands/secret/patch/diff.ts"],"names":[],"mappings":"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"}

package/dist/commands/secret/patch/operations.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Path parsing and set/unset operations for secret patching
+ */
+import { type ParsedPath, type PatchOperation, type AppliedOperation } from './types.js';
+/**
+ * Parse a dot-notation path into segments
+ * Supports:
+ * - key           -> top-level key
+ * - a.b.c         -> nested keys
+ * - arr[0]        -> array index
+ * - arr[+]        -> array append
+ * - a.b[0].c      -> mixed paths
+ *
+ * @param path - The path string to parse
+ * @returns ParsedPath with segments
+ */
+export declare function parsePath(path: string): ParsedPath;
+/**
+ * Infer the type of a string value and convert it
+ * - "true"/"false" -> boolean
+ * - numeric strings -> number
+ * - "null" -> null
+ * - otherwise -> string
+ *
+ * @param value - The string value to infer
+ * @returns The inferred value with correct type
+ */
+export declare function inferValueType(value: string): unknown;
+/**
+ * Parse a value that might be JSON
+ * If it starts with { or [, try to parse as JSON
+ * Otherwise use type inference
+ */
+export declare function parseValue(value: string): unknown;
+/**
+ * Get a value at a path from an object
+ */
+export declare function getAtPath(obj: unknown, parsedPath: ParsedPath): unknown;
+/**
+ * Set a value at a path in an object (mutates the object)
+ *
+ * @param obj - The object to modify
+ * @param parsedPath - The parsed path
+ * @param value - The value to set
+ * @returns The previous value at the path (if any)
+ */
+export declare function setAtPath(obj: Record<string, unknown>, parsedPath: ParsedPath, value: unknown): unknown;
+/**
+ * Remove a value at a path in an object (mutates the object)
+ *
+ * @param obj - The object to modify
+ * @param parsedPath - The parsed path
+ * @returns The removed value (if any)
+ */
+export declare function unsetAtPath(obj: Record<string, unknown>, parsedPath: ParsedPath): unknown;
+/**
+ * Apply a list of patch operations to an object
+ *
+ * @param obj - The object to modify (will be deep cloned)
+ * @param operations - The operations to apply
+ * @returns Array of applied operations with details
+ */
+export declare function applyOperations(obj: Record<string, unknown>, operations: PatchOperation[]): AppliedOperation[];
+/**
+ * Parse --set arguments into operations
+ * Format: path=value
+ */
+export declare function parseSetArgs(args: string[]): PatchOperation[];
+/**
+ * Parse --unset arguments into operations
+ */
+export declare function parseUnsetArgs(args: string[]): PatchOperation[];
+/**
+ * Deep clone an object
+ */
+export declare function deepClone<T>(obj: T): T;
+//# sourceMappingURL=operations.d.ts.map

package/dist/commands/secret/patch/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../src/commands/secret/patch/operations.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAEtB,MAAM,YAAY,CAAC;AAMpB;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA0ElD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAkBrD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAejD;AAMD;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAyBvE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,OAAO,GACb,OAAO,CAyDT;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CA+DT;AAMD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,UAAU,EAAE,cAAc,EAAE,GAC3B,gBAAgB,EAAE,CA0BpB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAoB7D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAK/D;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAEtC"}

package/dist/commands/secret/patch/operations.js

@@ -0,0 +1,351 @@
+// Path: src/commands/secret/patch/operations.ts
+/**
+ * Path parsing and set/unset operations for secret patching
+ */
+import { PatchError, } from './types.js';
+// ============================================================================
+// Path Parsing
+// ============================================================================
+/**
+ * Parse a dot-notation path into segments
+ * Supports:
+ * - key           -> top-level key
+ * - a.b.c         -> nested keys
+ * - arr[0]        -> array index
+ * - arr[+]        -> array append
+ * - a.b[0].c      -> mixed paths
+ *
+ * @param path - The path string to parse
+ * @returns ParsedPath with segments
+ */
+export function parsePath(path) {
+    if (!path || path.trim() === '') {
+        throw new PatchError('Empty path', 'INVALID_PATH', { path });
+    }
+    const segments = [];
+    let current = '';
+    let i = 0;
+    while (i < path.length) {
+        const char = path[i];
+        if (char === '.') {
+            // End of a key segment
+            if (current) {
+                segments.push({ type: 'key', key: current });
+                current = '';
+            }
+            i++;
+        }
+        else if (char === '[') {
+            // Start of array index
+            if (current) {
+                segments.push({ type: 'key', key: current });
+                current = '';
+            }
+            // Find closing bracket
+            const closingBracket = path.indexOf(']', i);
+            if (closingBracket === -1) {
+                throw new PatchError(`Unclosed bracket in path: ${path}`, 'INVALID_PATH', { path, position: i });
+            }
+            const indexStr = path.slice(i + 1, closingBracket);
+            if (indexStr === '+') {
+                // Append operation
+                segments.push({ type: 'append' });
+            }
+            else if (/^\d+$/.test(indexStr)) {
+                // Numeric index
+                segments.push({ type: 'index', index: parseInt(indexStr, 10) });
+            }
+            else {
+                throw new PatchError(`Invalid array index: ${indexStr}`, 'INVALID_PATH', { path, index: indexStr });
+            }
+            i = closingBracket + 1;
+            // Skip dot after bracket if present
+            if (i < path.length && path[i] === '.') {
+                i++;
+            }
+        }
+        else {
+            current += char;
+            i++;
+        }
+    }
+    // Add final segment
+    if (current) {
+        segments.push({ type: 'key', key: current });
+    }
+    if (segments.length === 0) {
+        throw new PatchError('Path has no valid segments', 'INVALID_PATH', { path });
+    }
+    return { segments, raw: path };
+}
+// ============================================================================
+// Value Type Inference
+// ============================================================================
+/**
+ * Infer the type of a string value and convert it
+ * - "true"/"false" -> boolean
+ * - numeric strings -> number
+ * - "null" -> null
+ * - otherwise -> string
+ *
+ * @param value - The string value to infer
+ * @returns The inferred value with correct type
+ */
+export function inferValueType(value) {
+    // Boolean
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // Null
+    if (value === 'null')
+        return null;
+    // Number (integer or float)
+    if (/^-?\d+$/.test(value)) {
+        return parseInt(value, 10);
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
+        return parseFloat(value);
+    }
+    // String (default)
+    return value;
+}
+/**
+ * Parse a value that might be JSON
+ * If it starts with { or [, try to parse as JSON
+ * Otherwise use type inference
+ */
+export function parseValue(value) {
+    const trimmed = value.trim();
+    // Try to parse as JSON for objects and arrays
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Not valid JSON, return as string
+            return value;
+        }
+    }
+    return inferValueType(value);
+}
+// ============================================================================
+// Set/Unset Operations
+// ============================================================================
+/**
+ * Get a value at a path from an object
+ */
+export function getAtPath(obj, parsedPath) {
+    let current = obj;
+    for (const segment of parsedPath.segments) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (segment.type === 'key') {
+            if (typeof current !== 'object' || Array.isArray(current)) {
+                return undefined;
+            }
+            current = current[segment.key];
+        }
+        else if (segment.type === 'index') {
+            if (!Array.isArray(current)) {
+                return undefined;
+            }
+            current = current[segment.index];
+        }
+        else {
+            // segment.type === 'append': Can't get from append position
+            return undefined;
+        }
+    }
+    return current;
+}
+/**
+ * Set a value at a path in an object (mutates the object)
+ *
+ * @param obj - The object to modify
+ * @param parsedPath - The parsed path
+ * @param value - The value to set
+ * @returns The previous value at the path (if any)
+ */
+export function setAtPath(obj, parsedPath, value) {
+    const { segments } = parsedPath;
+    // Navigate to parent, creating intermediate objects/arrays as needed
+    let current = obj;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        const nextSegment = segments[i + 1];
+        if (segment.type === 'key') {
+            const currentObj = current;
+            // Create intermediate container based on next segment type
+            currentObj[segment.key] ??= nextSegment.type === 'index' || nextSegment.type === 'append'
+                ? []
+                : {};
+            current = currentObj[segment.key];
+        }
+        else if (segment.type === 'index') {
+            const currentArr = current;
+            currentArr[segment.index] ??= nextSegment.type === 'index' || nextSegment.type === 'append'
+                ? []
+                : {};
+            current = currentArr[segment.index];
+        }
+        else {
+            throw new PatchError('Append operator [+] can only be used at the end of a path', 'INVALID_PATH', { path: parsedPath.raw });
+        }
+    }
+    // Set the final value
+    const lastSegment = segments[segments.length - 1];
+    let previousValue;
+    if (lastSegment.type === 'key') {
+        const parent = current;
+        previousValue = parent[lastSegment.key];
+        parent[lastSegment.key] = value;
+    }
+    else if (lastSegment.type === 'index') {
+        const parent = current;
+        previousValue = parent[lastSegment.index];
+        parent[lastSegment.index] = value;
+    }
+    else {
+        // lastSegment.type === 'append'
+        if (!Array.isArray(current)) {
+            throw new PatchError('Cannot append to non-array', 'TYPE_MISMATCH', { path: parsedPath.raw, actualType: typeof current });
+        }
+        current.push(value);
+        previousValue = undefined;
+    }
+    return previousValue;
+}
+/**
+ * Remove a value at a path in an object (mutates the object)
+ *
+ * @param obj - The object to modify
+ * @param parsedPath - The parsed path
+ * @returns The removed value (if any)
+ */
+export function unsetAtPath(obj, parsedPath) {
+    const { segments } = parsedPath;
+    // Navigate to parent
+    let current = obj;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        if (segment.type === 'key') {
+            const currentObj = current;
+            if (currentObj[segment.key] === undefined) {
+                return undefined; // Path doesn't exist
+            }
+            current = currentObj[segment.key];
+        }
+        else if (segment.type === 'index') {
+            const currentArr = current;
+            if (currentArr[segment.index] === undefined) {
+                return undefined;
+            }
+            current = currentArr[segment.index];
+        }
+        else {
+            throw new PatchError('Append operator [+] cannot be used with unset', 'UNSUPPORTED_OPERATION', { path: parsedPath.raw });
+        }
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+    }
+    // Remove the final value
+    const lastSegment = segments[segments.length - 1];
+    let removedValue;
+    if (lastSegment.type === 'key') {
+        if (typeof current !== 'object' || Array.isArray(current) || current === null) {
+            return undefined;
+        }
+        const parent = current;
+        const keyToDelete = lastSegment.key;
+        removedValue = parent[keyToDelete];
+        Reflect.deleteProperty(parent, keyToDelete);
+    }
+    else if (lastSegment.type === 'index') {
+        if (!Array.isArray(current)) {
+            return undefined;
+        }
+        const parent = current;
+        if (lastSegment.index >= 0 && lastSegment.index < parent.length) {
+            removedValue = parent[lastSegment.index];
+            parent.splice(lastSegment.index, 1);
+        }
+    }
+    else {
+        throw new PatchError('Append operator [+] cannot be used with unset', 'UNSUPPORTED_OPERATION', { path: parsedPath.raw });
+    }
+    return removedValue;
+}
+// ============================================================================
+// Apply Operations
+// ============================================================================
+/**
+ * Apply a list of patch operations to an object
+ *
+ * @param obj - The object to modify (will be deep cloned)
+ * @param operations - The operations to apply
+ * @returns Array of applied operations with details
+ */
+export function applyOperations(obj, operations) {
+    const applied = [];
+    for (const op of operations) {
+        const parsedPath = parsePath(op.path);
+        if (op.type === 'set') {
+            const previousValue = setAtPath(obj, parsedPath, op.value);
+            applied.push({
+                type: 'set',
+                path: op.path,
+                previousValue,
+                newValue: op.value,
+            });
+        }
+        else {
+            // op.type === 'unset'
+            const removedValue = unsetAtPath(obj, parsedPath);
+            applied.push({
+                type: 'unset',
+                path: op.path,
+                previousValue: removedValue,
+            });
+        }
+    }
+    return applied;
+}
+/**
+ * Parse --set arguments into operations
+ * Format: path=value
+ */
+export function parseSetArgs(args) {
+    return args.map(arg => {
+        const eqIndex = arg.indexOf('=');
+        if (eqIndex === -1) {
+            throw new PatchError(`Invalid --set argument: ${arg} (expected path=value)`, 'INVALID_VALUE', { arg });
+        }
+        const path = arg.slice(0, eqIndex);
+        const valueStr = arg.slice(eqIndex + 1);
+        return {
+            type: 'set',
+            path,
+            value: parseValue(valueStr),
+        };
+    });
+}
+/**
+ * Parse --unset arguments into operations
+ */
+export function parseUnsetArgs(args) {
+    return args.map(path => ({
+        type: 'unset',
+        path,
+    }));
+}
+/**
+ * Deep clone an object
+ */
+export function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+//# sourceMappingURL=operations.js.map