@phren/cli 0.0.9 → 0.0.11

package/mcp/dist/link-skills.js

@@ -108,7 +108,75 @@ export function readSkillManifestHooks(phrenPath) {
     }
     return Object.keys(result).length > 0 ? result : null;
 }
-// ── Skill linking helpers ───────────────────────────────────────────────────
+/**
+ * Returns true if `destPath` is a symlink whose resolved target lives under
+ * `managedRoot`.  Used to decide whether phren owns a symlink.
+ */
+export function isManagedSymlink(destPath, managedRoot) {
+    try {
+        const stat = fs.lstatSync(destPath);
+        if (!stat.isSymbolicLink())
+            return false;
+        const target = fs.readlinkSync(destPath);
+        const resolvedTarget = path.resolve(path.dirname(destPath), target);
+        const managedPrefix = path.resolve(managedRoot) + path.sep;
+        return resolvedTarget.startsWith(managedPrefix);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns true if `destPath` exists and is NOT a symlink that points into
+ * managedRoot — i.e. it's a file/dir the user owns.
+ */
+function isUserOwnedFile(destPath, managedRoot) {
+    try {
+        fs.lstatSync(destPath);
+    }
+    catch {
+        return false; // doesn't exist
+    }
+    return !isManagedSymlink(destPath, managedRoot);
+}
+/**
+ * Scan destDir for files that phren would want to link (based on srcDir) but
+ * can't because a user-owned file already occupies the destination slot.
+ */
+export function detectSkillCollisions(srcDir, destDir, managedRoot) {
+    if (!fs.existsSync(srcDir) || !fs.existsSync(destDir))
+        return [];
+    const collisions = [];
+    for (const entry of fs.readdirSync(srcDir)) {
+        const srcPath = path.join(srcDir, entry);
+        const stat = fs.statSync(srcPath);
+        if (stat.isFile() && entry.endsWith(".md")) {
+            const destPath = path.join(destDir, entry);
+            if (isUserOwnedFile(destPath, managedRoot)) {
+                const skillName = entry.replace(/\.md$/, "");
+                collisions.push({
+                    skillName,
+                    destPath,
+                    message: `Skill '${skillName}' — user file already exists at ${destPath}. Rename or remove it to use phren's version.`,
+                });
+            }
+        }
+        else if (stat.isDirectory()) {
+            const skillFile = path.join(srcPath, "SKILL.md");
+            if (fs.existsSync(skillFile)) {
+                const destPath = path.join(destDir, entry);
+                if (isUserOwnedFile(destPath, managedRoot)) {
+                    collisions.push({
+                        skillName: entry,
+                        destPath,
+                        message: `Skill '${entry}' — user directory already exists at ${destPath}. Rename or remove it to use phren's version.`,
+                    });
+                }
+            }
+        }
+    }
+    return collisions;
+}
 function cleanupManagedSkillLinks(destDir, expectedNames, managedRoot) {
     if (!fs.existsSync(destDir))
         return;
@@ -117,27 +185,22 @@ function cleanupManagedSkillLinks(destDir, expectedNames, managedRoot) {
             continue;
         const destPath = path.join(destDir, entry);
         try {
-            const stat = fs.lstatSync(destPath);
-            if (!stat.isSymbolicLink())
-                continue;
-            const target = fs.readlinkSync(destPath);
-            const resolvedTarget = path.resolve(path.dirname(destPath), target);
-            const managedPrefix = path.resolve(managedRoot) + path.sep;
-            if (!resolvedTarget.startsWith(managedPrefix))
+            if (!isManagedSymlink(destPath, managedRoot))
                 continue;
             fs.unlinkSync(destPath);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] cleanupManagedSkillLinks: ${errorMessage(err)}\n`);
         }
     }
 }
 export function linkSkillsDir(srcDir, destDir, managedRoot, symlinkFile, opts) {
     if (!fs.existsSync(srcDir))
-        return;
+        return [];
     fs.mkdirSync(destDir, { recursive: true });
     const expectedNames = new Set();
+    const collisions = [];
     for (const entry of fs.readdirSync(srcDir)) {
         const srcPath = path.join(srcDir, entry);
         const stat = fs.statSync(srcPath);
@@ -146,20 +209,43 @@ export function linkSkillsDir(srcDir, destDir, managedRoot, symlinkFile, opts) {
             continue;
         }
         if (stat.isFile() && entry.endsWith(".md")) {
+            const destPath = path.join(destDir, entry);
+            if (isUserOwnedFile(destPath, managedRoot)) {
+                const collision = {
+                    skillName,
+                    destPath,
+                    message: `Skipping skill '${skillName}' — user skill already exists at ${destPath}. To use phren's version, rename or remove your skill first.`,
+                };
+                collisions.push(collision);
+                process.stderr.write(`[phren] ${collision.message}\n`);
+                continue;
+            }
             expectedNames.add(entry);
-            symlinkFile(srcPath, path.join(destDir, entry), managedRoot);
+            symlinkFile(srcPath, destPath, managedRoot);
         }
         else if (stat.isDirectory()) {
             const skillFile = path.join(srcPath, "SKILL.md");
             if (fs.existsSync(skillFile)) {
+                const destPath = path.join(destDir, entry);
+                if (isUserOwnedFile(destPath, managedRoot)) {
+                    const collision = {
+                        skillName,
+                        destPath,
+                        message: `Skipping skill '${skillName}' — user skill already exists at ${destPath}. To use phren's version, rename or remove your skill first.`,
+                    };
+                    collisions.push(collision);
+                    process.stderr.write(`[phren] ${collision.message}\n`);
+                    continue;
+                }
                 expectedNames.add(entry);
                 // Symlink the entire skill directory so bundled scripts and assets are accessible.
                 // Relative paths in the skill body remain valid because the directory structure is preserved.
-                symlinkFile(srcPath, path.join(destDir, entry), managedRoot);
+                symlinkFile(srcPath, destPath, managedRoot);
             }
         }
     }
     cleanupManagedSkillLinks(destDir, expectedNames, managedRoot);
+    return collisions;
 }
 export function writeSkillMd(phrenPath) {
     const lifecycle = buildSharedLifecycleCommands();

package/mcp/dist/link.js

@@ -1,17 +1,17 @@
 import * as fs from "fs";
 import * as path from "path";
-import * as crypto from "crypto";
 import * as readline from "readline";
 import * as yaml from "js-yaml";
 import { execFileSync } from "child_process";
-import { fileURLToPath } from "url";
+import { ROOT } from "./package-metadata.js";
 import { configureClaude, configureCodexMcp, configureCopilotMcp, configureCursorMcp, configureVSCode, ensureGovernanceFiles, getHooksEnabledPreference, getMcpEnabledPreference, isVersionNewer, logMcpTargetStatus, patchJsonFile, setMcpEnabledPreference, } from "./init.js";
 import { configureAllHooks, detectInstalledTools } from "./hooks.js";
 import { getMachineName, persistMachineName } from "./machine-identity.js";
-import { debugLog, EXEC_TIMEOUT_MS, EXEC_TIMEOUT_QUICK_MS, isRecord, homePath, hookConfigPath, installPreferencesFile, } from "./shared.js";
+import { debugLog, EXEC_TIMEOUT_MS, EXEC_TIMEOUT_QUICK_MS, isRecord, homePath, hookConfigPath, installPreferencesFile, atomicWriteText, } from "./shared.js";
 import { errorMessage } from "./utils.js";
+import { log } from "./init-shared.js";
 import { listMachines as listMachinesShared, listProfiles as listProfilesShared, setMachineProfile, } from "./profile-store.js";
-import { writeSkillMd } from "./link-skills.js";
+import { writeSkillMd, isManagedSymlink } from "./link-skills.js";
 import { syncScopeSkillsToDir } from "./skill-files.js";
 import { renderSkillInstructionsSection } from "./skill-registry.js";
 import { findProjectDir } from "./project-locator.js";
@@ -23,14 +23,6 @@ export { updateFileChecksums, verifyFileChecksums } from "./link-checksums.js";
 export { findProjectDir } from "./project-locator.js";
 export { parseSkillFrontmatter, validateSkillFrontmatter, validateSkillsDir, readSkillManifestHooks, } from "./link-skills.js";
 // ── Helpers (exported for link-doctor) ──────────────────────────────────────
-const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-function log(msg) { process.stdout.write(msg + "\n"); }
-function atomicWriteText(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.tmp-${crypto.randomUUID()}`;
-    fs.writeFileSync(tmpPath, content);
-    fs.renameSync(tmpPath, filePath);
-}
 export { getMachineName } from "./machine-identity.js";
 export function lookupProfile(phrenPath, machine) {
     const listed = listMachinesShared(phrenPath);
@@ -123,7 +115,7 @@ function setupSparseCheckout(phrenPath, projects) {
         execFileSync("git", ["rev-parse", "--git-dir"], { cwd: phrenPath, stdio: "ignore", timeout: EXEC_TIMEOUT_QUICK_MS });
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] setupSparseCheckout notAGitRepo: ${errorMessage(err)}\n`);
         return;
     }
@@ -184,10 +176,9 @@ function symlinkFile(src, dest, managedRoot) {
         if (stat.isSymbolicLink()) {
             const currentTarget = fs.readlinkSync(dest);
             const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
-            const managedPrefix = path.resolve(managedRoot) + path.sep;
             if (resolvedTarget === path.resolve(src))
                 return true;
-            if (!resolvedTarget.startsWith(managedPrefix)) {
+            if (!isManagedSymlink(dest, managedRoot)) {
                 log(`  preserve existing symlink: ${dest}`);
                 return false;
             }
@@ -238,8 +229,7 @@ function writeManagedAgentsFile(src, dest, content, managedRoot) {
         if (stat.isSymbolicLink()) {
             const currentTarget = fs.readlinkSync(dest);
             const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
-            const managedPrefix = path.resolve(managedRoot) + path.sep;
-            if (resolvedTarget === path.resolve(src) || resolvedTarget.startsWith(managedPrefix)) {
+            if (resolvedTarget === path.resolve(src) || isManagedSymlink(dest, managedRoot)) {
                 fs.unlinkSync(dest);
             }
             else {
@@ -278,7 +268,7 @@ function linkGlobal(phrenPath, tools) {
                 symlinkFile(globalClaude, path.join(copilotInstrDir, "copilot-instructions.md"), phrenPath);
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                if ((process.env.PHREN_DEBUG))
                     process.stderr.write(`[phren] linkGlobal copilotInstructions: ${errorMessage(err)}\n`);
             }
         }
@@ -324,7 +314,7 @@ function linkProject(phrenPath, project, tools) {
                         symlinkFile(src, path.join(copilotDir, "copilot-instructions.md"), phrenPath);
                     }
                     catch (err) {
-                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                        if ((process.env.PHREN_DEBUG))
                             process.stderr.write(`[phren] linkProject copilotInstructions: ${errorMessage(err)}\n`);
                     }
                 }
@@ -348,7 +338,7 @@ function linkProject(phrenPath, project, tools) {
             addTokenAnnotation(claudeFile);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] linkProject tokenAnnotation: ${errorMessage(err)}\n`);
         }
     }
@@ -365,7 +355,7 @@ function linkProject(phrenPath, project, tools) {
                 excludeEntries.push("AGENTS.md");
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] linkProject agentsMd: ${errorMessage(err)}\n`);
         }
     }
@@ -506,7 +496,7 @@ export async function runLink(phrenPath, opts = {}) {
         mcpStatus = configureClaude(phrenPath, { mcpEnabled, hooksEnabled }) ?? "installed";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureClaude: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Claude", mcpStatus);
@@ -515,7 +505,7 @@ export async function runLink(phrenPath, opts = {}) {
         vsStatus = configureVSCode(phrenPath, { mcpEnabled }) ?? "no_vscode";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureVSCode: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("VS Code", vsStatus);
@@ -524,7 +514,7 @@ export async function runLink(phrenPath, opts = {}) {
         cursorStatus = configureCursorMcp(phrenPath, { mcpEnabled }) ?? "no_cursor";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCursorMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Cursor", cursorStatus);
@@ -533,7 +523,7 @@ export async function runLink(phrenPath, opts = {}) {
         copilotStatus = configureCopilotMcp(phrenPath, { mcpEnabled }) ?? "no_copilot";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCopilotMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Copilot CLI", copilotStatus);
@@ -542,7 +532,7 @@ export async function runLink(phrenPath, opts = {}) {
         codexStatus = configureCodexMcp(phrenPath, { mcpEnabled }) ?? "no_codex";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCodexMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Codex", codexStatus);
@@ -566,7 +556,7 @@ export async function runLink(phrenPath, opts = {}) {
         log(`  phren.SKILL.md written (agentskills-compatible tools)`);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link writeSkillMd: ${errorMessage(err)}\n`);
     }
     log("");

package/mcp/dist/machine-identity.js

@@ -1,17 +1,9 @@
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
-import * as crypto from "crypto";
-import { homePath } from "./shared.js";
+import { homePath, atomicWriteText } from "./shared.js";
 function phrenMachineFilePath() {
     return homePath(".phren", ".machine-id");
 }
-function atomicWriteText(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.tmp-${crypto.randomUUID()}`;
-    fs.writeFileSync(tmpPath, content);
-    fs.renameSync(tmpPath, filePath);
-}
 export function machineFilePath() {
     return phrenMachineFilePath();
 }