@tekmidian/devonthink-mcp 2.0.0 → 2.0.1

package/dist/tools/columnLayout.d.ts

@@ -2,29 +2,24 @@
  * columnLayout.ts — Read and copy DEVONthink column layouts for smart groups/rules.
  *
  * Column layouts for list views are stored in
- * ~/Library/Preferences/com.devon-technologies.think.plist under a "Columns" key.
- * Each smart group or rule window remembers its column configuration keyed by
- * the group/rule name or UUID.
+ * ~/Library/Preferences/com.devon-technologies.think.plist under three related keys
+ * per smart group or rule (keyed by name or UUID):
+ *
+ *   ListColumnsHorizontal-{name}
+ *     → Array of visible column identifiers in display order
+ *
+ *   TableView Columns ListColumnsHorizontal-{name}
+ *     → Array of ALL column identifiers (visible + hidden)
+ *
+ *   TableView Column Widths ListColumnsHorizontal-{name}
+ *     → Dict of { columnIdentifier: widthFloat }
+ *
+ * The plist may use a smart group's UUID instead of its display name.
  *
  * Tools exported:
  *   get_column_layout  — Read columns for a named smart group or rule
  *   copy_column_layout — Copy column layout from one smart group/rule to another
  */
-interface ColumnEntry {
-    identifier: string | null;
-    title: string | null;
-    width: number | null;
-    visible: boolean | null;
-    position: number | null;
-}
-interface GetColumnLayoutResult {
-    success: boolean;
-    name?: string;
-    plistKey?: string;
-    columns?: ColumnEntry[];
-    rawValue?: string;
-    error?: string;
-}
 export declare const getColumnLayoutTool: {
     name: string;
     description: string;
@@ -35,21 +30,22 @@ export declare const getColumnLayoutTool: {
                 type: string;
                 description: string;
             };
-            plistKey: {
+            uuid: {
                 type: string;
                 description: string;
             };
         };
         required: string[];
     };
-    run: (args: Record<string, unknown>) => Promise<GetColumnLayoutResult>;
+    run: (args: Record<string, unknown>) => Promise<unknown>;
 };
 interface CopyColumnLayoutResult {
     success: boolean;
     sourceName?: string;
     targetName?: string;
-    sourcePlistKey?: string;
-    targetPlistKey?: string;
+    resolvedSourceKey?: string;
+    resolvedTargetKey?: string;
+    keysCopied?: string[];
     message?: string;
     error?: string;
 }
@@ -67,11 +63,11 @@ export declare const copyColumnLayoutTool: {
                 type: string;
                 description: string;
             };
-            sourcePlistKey: {
+            sourceUuid: {
                 type: string;
                 description: string;
             };
-            targetPlistKey: {
+            targetUuid: {
                 type: string;
                 description: string;
             };

package/dist/tools/columnLayout.js

@@ -2,9 +2,19 @@
  * columnLayout.ts — Read and copy DEVONthink column layouts for smart groups/rules.
  *
  * Column layouts for list views are stored in
- * ~/Library/Preferences/com.devon-technologies.think.plist under a "Columns" key.
- * Each smart group or rule window remembers its column configuration keyed by
- * the group/rule name or UUID.
+ * ~/Library/Preferences/com.devon-technologies.think.plist under three related keys
+ * per smart group or rule (keyed by name or UUID):
+ *
+ *   ListColumnsHorizontal-{name}
+ *     → Array of visible column identifiers in display order
+ *
+ *   TableView Columns ListColumnsHorizontal-{name}
+ *     → Array of ALL column identifiers (visible + hidden)
+ *
+ *   TableView Column Widths ListColumnsHorizontal-{name}
+ *     → Dict of { columnIdentifier: widthFloat }
+ *
+ * The plist may use a smart group's UUID instead of its display name.
  *
  * Tools exported:
  *   get_column_layout  — Read columns for a named smart group or rule
@@ -24,7 +34,7 @@ const PLISTBUDDY = "/usr/libexec/PlistBuddy";
  */
 function plistRead(command) {
     try {
-        const result = execSync(`${PLISTBUDDY} -c "${command}" "${PLIST_PATH}"`, {
+        const result = execSync(`${PLISTBUDDY} -c ${shellQuote(command)} ${shellQuote(PLIST_PATH)}`, {
             encoding: "utf-8",
             timeout: 10000,
         });
@@ -35,84 +45,185 @@ function plistRead(command) {
     }
 }
 /**
- * Run PlistBuddy with a command that modifies the plist.
- * Returns true on success, false on failure.
+ * Shell-quote a string by wrapping in single quotes and escaping embedded single quotes.
+ */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Build the three plist keys for a given base name (name or UUID).
+ */
+function keysForName(name) {
+    return {
+        columnsKey: `ListColumnsHorizontal-${name}`,
+        tableViewColumnsKey: `TableView Columns ListColumnsHorizontal-${name}`,
+        tableViewWidthsKey: `TableView Column Widths ListColumnsHorizontal-${name}`,
+    };
+}
+/**
+ * Parse a PlistBuddy "Array { ... }" output into a string array.
+ */
+function parseArray(raw) {
+    const lines = raw
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l !== "" && l !== "Array {" && l !== "}");
+    return lines;
+}
+/**
+ * Parse a PlistBuddy "Dict { key = value ... }" output into a Record<string, number>.
+ */
+function parseWidthDict(raw) {
+    const result = {};
+    const lines = raw
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l !== "" && l !== "Dict {" && l !== "}");
+    for (const line of lines) {
+        const match = line.match(/^(\S+)\s*=\s*(.+)$/);
+        if (match) {
+            result[match[1]] = parseFloat(match[2]);
+        }
+    }
+    return result;
+}
+/**
+ * Get all distinct base names that exist in the plist for ListColumnsHorizontal entries.
+ * Returns up to `limit` names for error messages.
  */
-function plistWrite(command) {
+function getExistingNames(limit = 20) {
+    // Use Python to read the plist keys — more reliable for binary plists
+    const script = `
+import plistlib, re, sys
+with open('${PLIST_PATH}', 'rb') as f:
+    data = plistlib.load(f)
+prefix = 'ListColumnsHorizontal-'
+names = set()
+for k in data:
+    if k.startswith(prefix):
+        names.add(k[len(prefix):])
+    elif k.startswith('TableView Columns ' + prefix):
+        names.add(k[len('TableView Columns ' + prefix):])
+    elif k.startswith('TableView Column Widths ' + prefix):
+        names.add(k[len('TableView Column Widths ' + prefix):])
+# Exclude Outline variants
+names = [n for n in names if not n.startswith('Outline')]
+names.sort()
+print('\\n'.join(names[:${limit}]))
+`.trim();
     try {
-        execSync(`${PLISTBUDDY} -c "${command}" "${PLIST_PATH}"`, {
+        const result = execSync(`python3 -c ${shellQuote(script)}`, {
             encoding: "utf-8",
             timeout: 10000,
         });
-        return true;
+        return result.trim().split("\n").filter(Boolean);
     }
     catch {
-        return false;
+        return [];
     }
 }
 /**
- * Escape a PlistBuddy key name by replacing : with \\:.
- * Colons are path separators in PlistBuddy, so any colon in a key value
- * must be escaped.
+ * Fuzzy-search existing names in the plist for a partial match.
+ * Returns all names that include the search term (case-insensitive).
  */
-function escapePBKey(key) {
-    return key.replace(/:/g, "\\:");
+function findMatchingNames(searchTerm) {
+    const allNames = getExistingNames(200);
+    const lower = searchTerm.toLowerCase();
+    return allNames.filter((n) => n.toLowerCase().includes(lower));
 }
 /**
- * Read the integer count of items in a PlistBuddy array/dict.
+ * Look up column layout data for a single base name (exact match).
+ * Returns null if none of the three key variants exist.
  */
-function readCount(path) {
-    const raw = plistRead(`Print '${path}'`);
-    if (!raw)
-        return 0;
-    // PlistBuddy prints "Dict {", "Array {", or the value — count the entries
-    const lines = raw.split("\n").filter((l) => l.trim() !== "" && l.trim() !== "{" && l.trim() !== "}");
-    return lines.length;
+function readLayoutForName(baseName) {
+    const { columnsKey, tableViewColumnsKey, tableViewWidthsKey } = keysForName(baseName);
+    const rawColumns = plistRead(`Print ':${columnsKey}'`);
+    const rawTableViewColumns = plistRead(`Print ':${tableViewColumnsKey}'`);
+    const rawWidths = plistRead(`Print ':${tableViewWidthsKey}'`);
+    // If none of the three keys exist, this name has no layout stored
+    if (!rawColumns && !rawTableViewColumns && !rawWidths) {
+        return null;
+    }
+    const keysFound = [];
+    if (rawColumns)
+        keysFound.push(columnsKey);
+    if (rawTableViewColumns)
+        keysFound.push(tableViewColumnsKey);
+    if (rawWidths)
+        keysFound.push(tableViewWidthsKey);
+    return {
+        found: true,
+        name: baseName,
+        resolvedKey: baseName,
+        columns: rawColumns ? parseArray(rawColumns) : null,
+        tableViewColumns: rawTableViewColumns ? parseArray(rawTableViewColumns) : null,
+        widths: rawWidths ? parseWidthDict(rawWidths) : null,
+        keysFound,
+    };
 }
 const getColumnLayout = async (args) => {
-    const { name, plistKey } = args;
+    const { name, uuid } = args;
     if (!name || typeof name !== "string") {
         return { success: false, error: "name parameter is required" };
     }
-    // Try to find the columns key. DEVONthink stores view settings under various
-    // top-level keys. We attempt a few common patterns:
-    const escapedName = escapePBKey(name);
-    const keysToTry = plistKey
-        ? [plistKey]
-        : [
-            `Columns:${escapedName}`,
-            `NSTableView Columns ${escapedName}`,
-            `ViewState:${escapedName}:Columns`,
-            `SmartGroupColumns:${escapedName}`,
-            `ColumnState:${escapedName}`,
-        ];
-    for (const key of keysToTry) {
-        const raw = plistRead(`Print '${key}'`);
-        if (raw) {
+    // Try exact name first
+    const exactResult = readLayoutForName(name);
+    if (exactResult) {
+        return {
+            success: true,
+            ...exactResult,
+        };
+    }
+    // If a UUID was supplied, try that too
+    if (uuid && typeof uuid === "string") {
+        const uuidResult = readLayoutForName(uuid);
+        if (uuidResult) {
             return {
                 success: true,
-                name,
-                plistKey: key,
-                rawValue: raw,
-                columns: [],
+                ...uuidResult,
+                name, // Override with the human-readable name
             };
         }
     }
-    // Fallback: dump top-level keys so the user can find the right path
-    const topLevel = plistRead("Print :");
+    // Try fuzzy match against existing names
+    const fuzzyMatches = findMatchingNames(name);
+    if (fuzzyMatches.length === 1) {
+        // Single match — use it
+        const fuzzyResult = readLayoutForName(fuzzyMatches[0]);
+        if (fuzzyResult) {
+            return {
+                success: true,
+                ...fuzzyResult,
+                nameSearched: name,
+                note: `Exact name not found; matched "${fuzzyMatches[0]}" via partial search`,
+            };
+        }
+    }
+    // Not found — return helpful error with examples
+    const examples = getExistingNames(15);
+    if (fuzzyMatches.length > 1) {
+        return {
+            success: false,
+            name,
+            error: `No exact match for "${name}". Multiple partial matches found — be more specific.`,
+            partialMatches: fuzzyMatches,
+        };
+    }
     return {
         success: false,
         name,
-        error: `Column layout for "${name}" not found under common plist paths. ` +
-            "Try specifying the plistKey parameter. " +
-            `Top-level plist keys:\n${topLevel ?? "(could not read plist)"}`,
+        error: `No column layout found for "${name}". ` +
+            "This smart group may not have a custom layout yet (it will use defaults). " +
+            "Use copy_column_layout to copy an existing layout to it.",
+        exampleNames: examples,
     };
 };
 export const getColumnLayoutTool = {
     name: "get_column_layout",
     description: "Read the column layout for a DEVONthink smart group or smart rule from preferences. " +
-        "Returns the raw PlistBuddy value so you can inspect column names and widths. " +
-        'Input: { "name": "Jobs - To Review" } or { "name": "Jobs - To Review", "plistKey": "Columns:Jobs - To Review" }',
+        "Returns the ordered visible columns, all table view columns, and column widths. " +
+        "Looks up by name (or UUID). Supports partial name matching. " +
+        'Input: { "name": "Archivieren - Jobs" } or { "name": "Jobs", "uuid": "4A469368-..." }',
     inputSchema: {
         type: "object",
         properties: {
@@ -120,202 +231,184 @@ export const getColumnLayoutTool = {
                 type: "string",
                 description: "Name of the smart group or smart rule whose column layout to read",
             },
-            plistKey: {
+            uuid: {
                 type: "string",
-                description: "Optional explicit PlistBuddy key path (e.g. 'Columns:My Group'). " +
-                    "If omitted, common patterns are tried automatically.",
+                description: "Optional UUID of the smart group (fallback if name not found). " +
+                    "DEVONthink sometimes stores layouts under the UUID rather than the display name.",
             },
         },
         required: ["name"],
     },
     run: getColumnLayout,
 };
+/**
+ * Use Python plistlib to copy all three column layout keys from source to target.
+ * This handles nested structures (Array/Dict) correctly in a single atomic read/write.
+ */
+function copyLayoutViaPython(sourceBaseName, targetBaseName) {
+    const suffixes = [
+        "ListColumnsHorizontal",
+        "TableView Columns ListColumnsHorizontal",
+        "TableView Column Widths ListColumnsHorizontal",
+    ];
+    const script = `
+import plistlib, sys, os
+
+plist_path = '${PLIST_PATH}'
+source = '${sourceBaseName.replace(/'/g, "\\'")}'
+target = '${targetBaseName.replace(/'/g, "\\'")}'
+
+suffixes = [
+    'ListColumnsHorizontal',
+    'TableView Columns ListColumnsHorizontal',
+    'TableView Column Widths ListColumnsHorizontal',
+]
+
+with open(plist_path, 'rb') as f:
+    data = plistlib.load(f)
+
+copied = []
+for suffix in suffixes:
+    src_key = suffix + '-' + source
+    tgt_key = suffix + '-' + target
+    if src_key in data:
+        import copy
+        data[tgt_key] = copy.deepcopy(data[src_key])
+        copied.append(tgt_key)
+
+if not copied:
+    print('ERROR: no source keys found for: ' + source, file=sys.stderr)
+    sys.exit(1)
+
+with open(plist_path, 'wb') as f:
+    plistlib.dump(data, f, fmt=plistlib.FMT_BINARY)
+
+print('\\n'.join(copied))
+`.trim();
+    try {
+        const result = execSync(`python3 -c ${shellQuote(script)}`, {
+            encoding: "utf-8",
+            timeout: 15000,
+        });
+        const keysCopied = result.trim().split("\n").filter(Boolean);
+        return { ok: true, keysCopied };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        return { ok: false, keysCopied: [], error: errMsg };
+    }
+}
 const copyColumnLayout = async (args) => {
-    const { sourceName, targetName, sourcePlistKey, targetPlistKey } = args;
+    const { sourceName, targetName, sourceUuid, targetUuid } = args;
     if (!sourceName || typeof sourceName !== "string") {
         return { success: false, error: "sourceName parameter is required" };
     }
     if (!targetName || typeof targetName !== "string") {
         return { success: false, error: "targetName parameter is required" };
     }
-    // Resolve source key
-    const escapedSource = escapePBKey(sourceName);
-    const sourceKeysToTry = sourcePlistKey
-        ? [sourcePlistKey]
-        : [
-            `Columns:${escapedSource}`,
-            `NSTableView Columns ${escapedSource}`,
-            `ViewState:${escapedSource}:Columns`,
-            `SmartGroupColumns:${escapedSource}`,
-            `ColumnState:${escapedSource}`,
-        ];
+    // Resolve source: try exact name, then UUID, then fuzzy
     let resolvedSourceKey = null;
-    let sourceValue = null;
-    for (const key of sourceKeysToTry) {
-        const raw = plistRead(`Print '${key}'`);
-        if (raw) {
-            resolvedSourceKey = key;
-            sourceValue = raw;
-            break;
-        }
+    if (readLayoutForName(sourceName)) {
+        resolvedSourceKey = sourceName;
     }
-    if (!resolvedSourceKey || !sourceValue) {
-        return {
-            success: false,
-            sourceName,
-            targetName,
-            error: `Source column layout for "${sourceName}" not found. Try specifying sourcePlistKey.`,
-        };
-    }
-    // Resolve target key (same pattern, replacing source name with target name)
-    const escapedTarget = escapePBKey(targetName);
-    let resolvedTargetKey;
-    if (targetPlistKey) {
-        resolvedTargetKey = targetPlistKey;
+    else if (sourceUuid && readLayoutForName(sourceUuid)) {
+        resolvedSourceKey = sourceUuid;
     }
     else {
-        // Mirror the source key pattern but with the target name
-        resolvedTargetKey = resolvedSourceKey.replace(escapedSource, escapedTarget);
-    }
-    // Check if target key already exists — if so, delete it first
-    const existingTarget = plistRead(`Print '${resolvedTargetKey}'`);
-    if (existingTarget) {
-        const deleted = plistWrite(`Delete '${resolvedTargetKey}'`);
-        if (!deleted) {
+        const fuzzy = findMatchingNames(sourceName);
+        if (fuzzy.length === 1 && readLayoutForName(fuzzy[0])) {
+            resolvedSourceKey = fuzzy[0];
+        }
+        else if (fuzzy.length > 1) {
             return {
                 success: false,
                 sourceName,
                 targetName,
-                sourcePlistKey: resolvedSourceKey,
-                targetPlistKey: resolvedTargetKey,
-                error: `Could not delete existing target key: ${resolvedTargetKey}`,
+                error: `Ambiguous source name "${sourceName}". Multiple matches: ${fuzzy.slice(0, 8).join(", ")}`,
             };
         }
     }
-    // PlistBuddy does not have a native copy command.
-    // Strategy: export source value as XML then import it at the target key.
-    // We use a temp file approach with plutil + PlistBuddy.
-    const os = await import("node:os");
-    const fs = await import("node:fs");
-    const tmpFile = join(os.tmpdir(), `dt-column-copy-${Date.now()}.plist`);
-    try {
-        // Export current plist to XML
-        execSync(`plutil -convert xml1 -o "${tmpFile}" "${PLIST_PATH}"`, {
-            encoding: "utf-8",
-            timeout: 10000,
-        });
-        // Read the source value from the xml copy (same key)
-        const sourceFromTmp = plistRead(`Print '${resolvedSourceKey}'`);
-        if (!sourceFromTmp) {
-            fs.unlinkSync(tmpFile);
-            return {
-                success: false,
-                error: "Could not re-read source value after XML conversion",
-            };
-        }
-        // The safest way to copy is to use PlistBuddy on the tmp file to
-        // get the XML fragment, then use Add command on the original.
-        // However, PlistBuddy cannot directly export a subtree as XML.
-        // Instead we detect the type and use a simpler approach:
-        // read individual leaf values and reconstruct with Add commands.
-        //
-        // For now, return what we found and indicate manual steps needed for
-        // complex nested structures. If the source is a simple string:
-        const trimmed = sourceValue.trim();
-        const isSimpleValue = !trimmed.startsWith("Dict") && !trimmed.startsWith("Array");
-        if (isSimpleValue) {
-            // Determine plist type and add
-            const numVal = Number(trimmed);
-            if (!isNaN(numVal) && trimmed !== "") {
-                plistWrite(`Add '${resolvedTargetKey}' integer ${trimmed}`);
-            }
-            else if (trimmed === "true" || trimmed === "false") {
-                plistWrite(`Add '${resolvedTargetKey}' bool ${trimmed}`);
-            }
-            else {
-                const escaped = trimmed.replace(/'/g, "'\\''");
-                plistWrite(`Add '${resolvedTargetKey}' string '${escaped}'`);
-            }
-            // Verify
-            const written = plistRead(`Print '${resolvedTargetKey}'`);
-            fs.unlinkSync(tmpFile);
-            if (written) {
-                return {
-                    success: true,
-                    sourceName,
-                    targetName,
-                    sourcePlistKey: resolvedSourceKey,
-                    targetPlistKey: resolvedTargetKey,
-                    message: `Column layout copied from "${sourceName}" to "${targetName}". Value: ${written}`,
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    error: "Write appeared to succeed but key is not readable after write",
-                };
-            }
-        }
-        // Complex nested structure — return info so user can inspect and act
-        fs.unlinkSync(tmpFile);
+    if (!resolvedSourceKey) {
+        const examples = getExistingNames(10);
         return {
             success: false,
             sourceName,
             targetName,
-            sourcePlistKey: resolvedSourceKey,
-            targetPlistKey: resolvedTargetKey,
-            error: "Source layout is a complex nested structure (Dict/Array). " +
-                "Automated copy of nested plist structures requires iterating each child key. " +
-                `Source value:\n${sourceValue}\n\n` +
-                "Use get_column_layout to inspect the structure, then use shell PlistBuddy " +
-                "commands to copy individual entries manually.",
+            error: `Source column layout for "${sourceName}" not found. ` +
+                "This smart group may not have a custom layout saved yet. " +
+                `Known layouts include: ${examples.slice(0, 8).join(", ")}`,
         };
     }
-    catch (err) {
-        try {
-            const fs = await import("node:fs");
-            if (fs.existsSync(tmpFile))
-                fs.unlinkSync(tmpFile);
-        }
-        catch {
-            // ignore cleanup error
-        }
+    // Resolve target base name: prefer UUID if supplied and different from name,
+    // otherwise use the display name (DEVONthink will save new layouts by name).
+    const resolvedTargetKey = targetUuid ?? targetName;
+    // Perform the copy via Python
+    const copyResult = copyLayoutViaPython(resolvedSourceKey, resolvedTargetKey);
+    if (!copyResult.ok) {
         return {
             success: false,
-            error: `Failed during copy operation: ${err instanceof Error ? err.message : String(err)}`,
+            sourceName,
+            targetName,
+            resolvedSourceKey,
+            resolvedTargetKey,
+            error: `Copy failed: ${copyResult.error}`,
         };
     }
+    // Verify by reading back the target
+    const verification = readLayoutForName(resolvedTargetKey);
+    if (!verification) {
+        return {
+            success: false,
+            sourceName,
+            targetName,
+            resolvedSourceKey,
+            resolvedTargetKey,
+            error: "Copy appeared to succeed but target keys not readable after write",
+        };
+    }
+    return {
+        success: true,
+        sourceName,
+        targetName,
+        resolvedSourceKey,
+        resolvedTargetKey,
+        keysCopied: copyResult.keysCopied,
+        message: `Copied column layout from "${sourceName}" to "${targetName}". ` +
+            `Keys written: ${copyResult.keysCopied.join(", ")}. ` +
+            `Columns: [${verification.columns?.join(", ") ?? "n/a"}]. ` +
+            "Restart DEVONthink or close/reopen the smart group window for the change to take effect.",
+    };
 };
 export const copyColumnLayoutTool = {
     name: "copy_column_layout",
-    description: "Copy the column layout from one DEVONthink smart group or smart rule to another. " +
-        "Reads the source layout from preferences and writes it to the target key. " +
-        "For simple (non-nested) values, the copy is performed automatically. " +
-        "For complex nested layouts, the source value is returned for manual inspection. " +
-        'Input: { "sourceName": "Jobs - To Review", "targetName": "Jobs - Archive" }',
+    description: "Copy the column layout (column order, visible columns, and column widths) from one " +
+        "DEVONthink smart group or smart rule to another. " +
+        "All three layout keys are copied atomically. Supports partial name matching. " +
+        'Input: { "sourceName": "Archivieren - Jobs", "targetName": "Jobs - To Review" }',
     inputSchema: {
         type: "object",
         properties: {
             sourceName: {
                 type: "string",
-                description: "Name of the source smart group or smart rule",
+                description: "Name of the source smart group or smart rule (must have a saved layout)",
             },
             targetName: {
                 type: "string",
                 description: "Name of the target smart group or smart rule to copy the layout to",
             },
-            sourcePlistKey: {
+            sourceUuid: {
                 type: "string",
-                description: "Optional explicit PlistBuddy key path for the source",
+                description: "Optional UUID of the source smart group (fallback if name lookup fails). " +
+                    "DEVONthink sometimes stores layouts under the UUID.",
             },
-            targetPlistKey: {
+            targetUuid: {
                 type: "string",
-                description: "Optional explicit PlistBuddy key path for the target",
+                description: "Optional UUID of the target smart group. If supplied, the layout is written " +
+                    "under the UUID key (which DEVONthink prefers for smart groups).",
             },
         },
         required: ["sourceName", "targetName"],
     },
     run: copyColumnLayout,
 };
-void readCount; // suppress unused warning — kept for future use
 //# sourceMappingURL=columnLayout.js.map