@phren/cli 0.0.1

package/mcp/dist/proactivity.js

@@ -0,0 +1,172 @@
+import * as fs from "fs";
+import { bootstrapPhrenDotEnv } from "./phren-dotenv.js";
+import { debugLog, findPhrenPath } from "./phren-paths.js";
+import { governanceInstallPreferencesFile, readInstallPreferences } from "./init-preferences.js";
+import { errorMessage } from "./utils.js";
+import { getWorkflowPolicy } from "./governance-policy.js";
+export const PROACTIVITY_LEVELS = ["high", "medium", "low"];
+const DEFAULT_PROACTIVITY_LEVEL = "high";
+const EXPLICIT_FINDING_SIGNAL_PATTERN = /\b(add finding|worth remembering)\b/i;
+const EXPLICIT_FINDING_TAG_PATTERN = /\[(pitfall|decision|pattern|tradeoff|architecture|bug)\]/i;
+const EXPLICIT_TASK_SIGNAL_PATTERN = /\b(?:add(?:\s+(?:this|that|it))?\s+(?:to\s+(?:the\s+)?)?(?:task|todo(?:\s+list)?|task(?:\s+list)?)|add\s+(?:a\s+)?task|put(?:\s+(?:this|that|it))?\s+(?:in|on)\s+(?:the\s+)?(?:task|todo(?:\s+list)?|task(?:\s+list)?))\b/i;
+function parseProactivityLevel(raw) {
+    if (!raw)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    return PROACTIVITY_LEVELS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+function resolveProactivityPhrenPath(explicitPhrenPath) {
+    return explicitPhrenPath ?? findPhrenPath();
+}
+function readGovernanceProactivityPreferences(explicitPhrenPath) {
+    const phrenPath = resolveProactivityPhrenPath(explicitPhrenPath);
+    if (!phrenPath)
+        return {};
+    const filePath = governanceInstallPreferencesFile(phrenPath);
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return {
+            proactivity: parseProactivityLevel(parsed?.proactivity),
+            proactivityFindings: parseProactivityLevel(parsed?.proactivityFindings),
+            proactivityTask: parseProactivityLevel(parsed?.proactivityTask),
+        };
+    }
+    catch (err) {
+        debugLog(`readGovernanceProactivityPreferences: failed to parse ${filePath}: ${errorMessage(err)}`);
+    }
+    return {};
+}
+function getConfiguredProactivityDefault(explicitPhrenPath) {
+    const governancePreference = readGovernanceProactivityPreferences(explicitPhrenPath).proactivity;
+    if (governancePreference)
+        return governancePreference;
+    const phrenPath = resolveProactivityPhrenPath(explicitPhrenPath);
+    if (phrenPath) {
+        const runtimePreference = parseProactivityLevel(readInstallPreferences(phrenPath).proactivity);
+        if (runtimePreference)
+            return runtimePreference;
+    }
+    return DEFAULT_PROACTIVITY_LEVEL;
+}
+/** Map findingSensitivity from workflow-policy.json to a ProactivityLevel. */
+function sensitivityToProactivity(sensitivity) {
+    switch (sensitivity) {
+        case "minimal": return "low";
+        case "conservative": return "medium";
+        case "balanced": return "high";
+        case "aggressive": return "high";
+        default: return undefined;
+    }
+}
+function getWorkflowPolicySensitivityLevel(explicitPhrenPath) {
+    const phrenPath = resolveProactivityPhrenPath(explicitPhrenPath);
+    if (!phrenPath)
+        return undefined;
+    try {
+        const policy = getWorkflowPolicy(phrenPath);
+        return sensitivityToProactivity(policy.findingSensitivity);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath) {
+    const prefs = readGovernanceProactivityPreferences(explicitPhrenPath);
+    return prefs.proactivityFindings
+        ?? prefs.proactivity
+        ?? getWorkflowPolicySensitivityLevel(explicitPhrenPath)
+        ?? getConfiguredProactivityDefault(explicitPhrenPath);
+}
+function getConfiguredProactivityLevelForTaskDefault(explicitPhrenPath) {
+    const prefs = readGovernanceProactivityPreferences(explicitPhrenPath);
+    return prefs.proactivityTask
+        ?? prefs.proactivity
+        ?? getWorkflowPolicySensitivityLevel(explicitPhrenPath)
+        ?? getConfiguredProactivityDefault(explicitPhrenPath);
+}
+function resolveProactivityLevel(raw, fallback) {
+    return parseProactivityLevel(raw) ?? fallback;
+}
+export function getProactivityLevel(explicitPhrenPath) {
+    bootstrapPhrenDotEnv();
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityDefault(explicitPhrenPath));
+}
+export function getProactivityLevelForFindings(explicitPhrenPath) {
+    bootstrapPhrenDotEnv();
+    const findingsPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_FINDINGS ?? (process.env.PHREN_PROACTIVITY_FINDINGS));
+    if (findingsPreference)
+        return findingsPreference;
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath));
+}
+export function getProactivityLevelForTask(explicitPhrenPath) {
+    bootstrapPhrenDotEnv();
+    const taskPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_TASKS ?? (process.env.PHREN_PROACTIVITY_TASKS));
+    if (taskPreference)
+        return taskPreference;
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityLevelForTaskDefault(explicitPhrenPath));
+}
+export function hasExplicitFindingSignal(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return EXPLICIT_FINDING_SIGNAL_PATTERN.test(text) || EXPLICIT_FINDING_TAG_PATTERN.test(text);
+    });
+}
+export function hasExplicitTaskSignal(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return EXPLICIT_TASK_SIGNAL_PATTERN.test(text);
+    });
+}
+export function shouldAutoCaptureFindingsForLevel(level, ...texts) {
+    if (level === "high")
+        return true;
+    if (level === "low")
+        return false;
+    return hasExplicitFindingSignal(...texts);
+}
+export function shouldAutoCaptureTaskForLevel(level, ...texts) {
+    if (level === "high")
+        return true;
+    if (level === "low")
+        return false;
+    return hasExplicitTaskSignal(...texts);
+}
+// ── Intent-aware auto task signals ──────────────────────────────────────────
+const EXECUTION_INTENT_PATTERN = /\b(?:yes\s+do\s+it|do\s+it|go\s+ahead|work\s+on\s+(?:these|this|that|it)|let(?:'|')s\s+(?:build|ship|implement|start|do|go)|approve(?:d)?|ship\s+it|merge\s+it|commit|proceed|execute|deploy|push\s+it|make\s+it\s+happen|get\s+(?:it|this|that)\s+done)\b/i;
+const DISCOVERY_INTENT_PATTERN = /\b(?:brainstorm|explore|what\s+if|ideas?\b|review\s+findings|think\s+about|consider|hypothetical|might\s+we|could\s+we\s+try|what\s+are\s+(?:the|some)\s+(?:options|alternatives|possibilities)|pros?\s+(?:and|&)\s+cons?|compare|evaluate|assess|weigh)\b/i;
+export function hasExecutionIntent(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return EXECUTION_INTENT_PATTERN.test(text);
+    });
+}
+export function hasDiscoveryIntent(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return DISCOVERY_INTENT_PATTERN.test(text);
+    });
+}
+const SUPPRESS_TASK_PATTERN = /\b(?:don(?:'|\u2019)t\s+(?:create|add|track|make)\s+(?:a\s+)?task|no\s+task|skip\s+(?:the\s+)?task|don(?:'|\u2019)t\s+add\s+(?:that|this|those)\s+to\s+task|do\s+not\s+add|not\s+a\s+task|just\s+(?:a\s+)?question|just\s+asking|hypothetically|just\s+curious|ignore\s+(?:this|that))\b/i;
+export function hasSuppressTaskIntent(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return SUPPRESS_TASK_PATTERN.test(text);
+    });
+}
+const CODE_CHANGE_PATTERN = /\b(?:git\s+(?:diff|status|add|commit|log)|npm\s+(?:run|test|build)|(?:edit|fix|change|update|modify)\s+(?:the\s+)?(?:file|code|function|method|class)|diff|patch|pull\s+request|pr\s+#?\d+|changed\s+file|modified\s+file|deleted\s+file|added\s+file|renamed\s+file)\b/i;
+export function hasCodeChangeContext(...texts) {
+    return texts.some((text) => {
+        if (!text)
+            return false;
+        return CODE_CHANGE_PATTERN.test(text);
+    });
+}

package/mcp/dist/profile-store.js

@@ -0,0 +1,228 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import * as yaml from "js-yaml";
+import { phrenErr, PhrenError, phrenOk, forwardErr, getProjectDirs, readRootManifest, } from "./shared.js";
+import { defaultMachineName, getMachineName } from "./machine-identity.js";
+import { withFileLock as withFileLockRaw } from "./shared-governance.js";
+import { errorMessage, isValidProjectName } from "./utils.js";
+import { TASK_FILE_ALIASES } from "./data-tasks.js";
+function withSafeLock(filePath, fn) {
+    try {
+        return withFileLockRaw(filePath, fn);
+    }
+    catch (err) {
+        const msg = errorMessage(err);
+        if (msg.includes("could not acquire lock")) {
+            return phrenErr(`Could not acquire write lock for "${path.basename(filePath)}". Another write may be in progress; please retry.`, PhrenError.LOCK_TIMEOUT);
+        }
+        throw err;
+    }
+}
+export function resolveActiveProfile(phrenPath, requestedProfile) {
+    const manifest = readRootManifest(phrenPath);
+    if (manifest?.installMode === "project-local") {
+        return phrenOk(undefined);
+    }
+    if (requestedProfile) {
+        const profiles = listProfiles(phrenPath);
+        if (!profiles.ok)
+            return forwardErr(profiles);
+        const exists = profiles.data.some((entry) => entry.name === requestedProfile);
+        if (!exists)
+            return phrenErr(`Profile "${requestedProfile}" not found.`, PhrenError.NOT_FOUND);
+        return phrenOk(requestedProfile);
+    }
+    const machines = listMachines(phrenPath);
+    if (machines.ok) {
+        const profiles = listProfiles(phrenPath);
+        if (!profiles.ok)
+            return phrenOk(undefined);
+        const candidates = [getMachineName(), defaultMachineName()].filter((value, index, values) => value && values.indexOf(value) === index);
+        for (const machineName of candidates) {
+            const mapped = machines.data[machineName];
+            if (!mapped)
+                continue;
+            const exists = profiles.data.some((entry) => entry.name === mapped);
+            if (exists)
+                return phrenOk(mapped);
+        }
+    }
+    const profiles = listProfiles(phrenPath);
+    if (!profiles.ok)
+        return phrenOk(undefined);
+    return phrenOk(profiles.data[0]?.name);
+}
+export function listMachines(phrenPath) {
+    const machinesPath = path.join(phrenPath, "machines.yaml");
+    if (!fs.existsSync(machinesPath))
+        return phrenErr(`machines.yaml not found. Run 'npx phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
+    try {
+        const raw = fs.readFileSync(machinesPath, "utf8");
+        const parsed = yaml.load(raw, { schema: yaml.CORE_SCHEMA });
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return phrenErr(`machines.yaml is empty or not valid YAML. Check the file format or run 'phren doctor --fix'.`, PhrenError.MALFORMED_YAML);
+        const cleaned = {};
+        for (const [machine, profile] of Object.entries(parsed)) {
+            if (typeof machine !== "string" || !machine.trim())
+                continue;
+            if (typeof profile !== "string" || !profile.trim())
+                continue;
+            cleaned[machine] = profile;
+        }
+        return phrenOk(cleaned);
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] listMachines yaml parse: ${errorMessage(err)}\n`);
+        return phrenErr(`Could not parse machines.yaml. Check the file for syntax errors or run 'phren doctor --fix'.`, PhrenError.MALFORMED_YAML);
+    }
+}
+function writeMachines(phrenPath, data) {
+    const machinesPath = path.join(phrenPath, "machines.yaml");
+    const backupPath = `${machinesPath}.bak`;
+    const existing = fs.existsSync(machinesPath) ? fs.readFileSync(machinesPath, "utf8") : "";
+    if (fs.existsSync(machinesPath))
+        fs.copyFileSync(machinesPath, backupPath);
+    const ordered = Object.fromEntries(Object.entries(data).sort(([a], [b]) => a.localeCompare(b)));
+    const headerLines = [];
+    for (const line of existing.split("\n")) {
+        if (line.startsWith("#") || line.trim() === "") {
+            headerLines.push(line);
+            continue;
+        }
+        break;
+    }
+    const header = headerLines.length ? `${headerLines.join("\n")}\n` : "";
+    const tmpPath = `${machinesPath}.tmp-${crypto.randomUUID()}`;
+    fs.writeFileSync(tmpPath, header + yaml.dump(ordered, { lineWidth: 1000 }));
+    fs.renameSync(tmpPath, machinesPath);
+}
+export function setMachineProfile(phrenPath, machine, profile) {
+    if (!machine || !profile)
+        return phrenErr(`Both machine name and profile name are required. Example: :machine map my-laptop personal`, PhrenError.EMPTY_INPUT);
+    const profiles = listProfiles(phrenPath);
+    if (profiles.ok) {
+        const exists = profiles.data.some((entry) => entry.name === profile);
+        if (!exists)
+            return phrenErr(`Profile "${profile}" does not exist. Check available profiles in the profiles/ directory.`, PhrenError.NOT_FOUND);
+    }
+    const machinesPath = path.join(phrenPath, "machines.yaml");
+    return withSafeLock(machinesPath, () => {
+        const current = listMachines(phrenPath);
+        const data = current.ok ? current.data : {};
+        data[machine] = profile;
+        writeMachines(phrenPath, data);
+        return phrenOk(`Mapped machine ${machine} -> ${profile}.`);
+    });
+}
+export function listProfiles(phrenPath) {
+    const profilesDir = path.join(phrenPath, "profiles");
+    if (!fs.existsSync(profilesDir))
+        return phrenErr(`No profiles/ directory found. Run 'npx phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
+    const files = fs.readdirSync(profilesDir).filter((file) => file.endsWith(".yaml")).sort();
+    const profiles = [];
+    for (const file of files) {
+        const full = path.join(profilesDir, file);
+        try {
+            const raw = fs.readFileSync(full, "utf8");
+            const parsed = yaml.load(raw, { schema: yaml.CORE_SCHEMA });
+            const data = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+            const name = (typeof data?.name === "string" && data.name.trim())
+                ? data.name
+                : file.replace(/\.yaml$/, "");
+            const projects = Array.isArray(data?.projects)
+                ? data.projects.map((project) => String(project)).filter(Boolean)
+                : [];
+            profiles.push({ name, file: full, projects });
+        }
+        catch (err) {
+            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                process.stderr.write(`[phren] listProfiles yamlParse: ${errorMessage(err)}\n`);
+            return phrenErr(`profiles/${file}`, PhrenError.MALFORMED_YAML);
+        }
+    }
+    return phrenOk(profiles);
+}
+function writeProfile(file, name, projects) {
+    const backup = `${file}.bak`;
+    if (fs.existsSync(file))
+        fs.copyFileSync(file, backup);
+    const normalized = [...new Set(projects)].sort();
+    const out = yaml.dump({ name, projects: normalized }, { lineWidth: 1000 });
+    const tmpPath = `${file}.tmp-${crypto.randomUUID()}`;
+    fs.writeFileSync(tmpPath, out);
+    fs.renameSync(tmpPath, file);
+}
+export function addProjectToProfile(phrenPath, profile, project) {
+    if (!isValidProjectName(project))
+        return phrenErr(`Project name "${project}" is not valid. Use lowercase letters, numbers, and hyphens (e.g. "my-project").`, PhrenError.INVALID_PROJECT_NAME);
+    const profiles = listProfiles(phrenPath);
+    if (!profiles.ok)
+        return forwardErr(profiles);
+    const current = profiles.data.find((entry) => entry.name === profile);
+    if (!current)
+        return phrenErr(`Profile "${profile}" not found.`, PhrenError.NOT_FOUND);
+    return withSafeLock(current.file, () => {
+        const refreshed = listProfiles(phrenPath);
+        if (!refreshed.ok)
+            return forwardErr(refreshed);
+        const latest = refreshed.data.find((entry) => entry.name === profile);
+        if (!latest)
+            return phrenErr(`Profile "${profile}" not found.`, PhrenError.NOT_FOUND);
+        const projects = latest.projects.includes(project) ? latest.projects : [...latest.projects, project];
+        writeProfile(latest.file, latest.name, projects);
+        return phrenOk(`Added ${project} to profile ${profile}.`);
+    });
+}
+export function removeProjectFromProfile(phrenPath, profile, project) {
+    const profiles = listProfiles(phrenPath);
+    if (!profiles.ok)
+        return forwardErr(profiles);
+    const current = profiles.data.find((entry) => entry.name === profile);
+    if (!current)
+        return phrenErr(`Profile "${profile}" not found.`, PhrenError.NOT_FOUND);
+    return withSafeLock(current.file, () => {
+        const refreshed = listProfiles(phrenPath);
+        if (!refreshed.ok)
+            return forwardErr(refreshed);
+        const latest = refreshed.data.find((entry) => entry.name === profile);
+        if (!latest)
+            return phrenErr(`Profile "${profile}" not found.`, PhrenError.NOT_FOUND);
+        const projects = latest.projects.filter((entry) => entry !== project);
+        writeProfile(latest.file, latest.name, projects);
+        return phrenOk(`Removed ${project} from profile ${profile}.`);
+    });
+}
+function buildProjectCard(dir) {
+    const name = path.basename(dir);
+    const summaryFile = path.join(dir, "summary.md");
+    const claudeFile = path.join(dir, "CLAUDE.md");
+    const summarySource = fs.existsSync(summaryFile)
+        ? fs.readFileSync(summaryFile, "utf8")
+        : fs.existsSync(claudeFile)
+            ? fs.readFileSync(claudeFile, "utf8")
+            : "";
+    const summary = summarySource
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line && !line.startsWith("#")) || "";
+    const docs = ["CLAUDE.md", "FINDINGS.md", "summary.md", "MEMORY_QUEUE.md"]
+        .filter((file) => fs.existsSync(path.join(dir, file)));
+    const taskFile = TASK_FILE_ALIASES.find((file) => fs.existsSync(path.join(dir, file)));
+    if (taskFile)
+        docs.push(taskFile);
+    return { name, summary, docs };
+}
+export function listProjectCards(phrenPath, profile) {
+    const dirs = getProjectDirs(phrenPath, profile).sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+    const cards = dirs.map(buildProjectCard);
+    // Prepend global as a pinned entry so it's always accessible from the shell
+    const globalDir = path.join(phrenPath, "global");
+    if (fs.existsSync(globalDir)) {
+        cards.unshift(buildProjectCard(globalDir));
+    }
+    return cards;
+}

package/mcp/dist/project-config.js

@@ -0,0 +1,85 @@
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { readInstallPreferences } from "./init-preferences.js";
+import { debugLog } from "./shared.js";
+import { errorMessage } from "./utils.js";
+export const PROJECT_OWNERSHIP_MODES = ["phren-managed", "detached", "repo-managed"];
+export const PROJECT_HOOK_EVENTS = ["UserPromptSubmit", "Stop", "SessionStart", "PostToolUse"];
+export function parseProjectOwnershipMode(raw) {
+    if (!raw)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "phren" || normalized === "managed" || normalized === "phren")
+        return "phren-managed";
+    if (normalized === "repo" || normalized === "external")
+        return "repo-managed";
+    if (PROJECT_OWNERSHIP_MODES.includes(normalized)) {
+        return normalized;
+    }
+    return undefined;
+}
+export function projectConfigPath(phrenPath, project) {
+    return path.join(phrenPath, project, "phren.project.yaml");
+}
+export function readProjectConfig(phrenPath, project) {
+    const configPath = projectConfigPath(phrenPath, project);
+    if (!fs.existsSync(configPath))
+        return {};
+    try {
+        const parsed = yaml.load(fs.readFileSync(configPath, "utf8"), { schema: yaml.CORE_SCHEMA });
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch (err) {
+        debugLog(`readProjectConfig: failed to parse ${configPath}: ${errorMessage(err)}`);
+        return {};
+    }
+}
+export function writeProjectConfig(phrenPath, project, patch) {
+    const configPath = projectConfigPath(phrenPath, project);
+    const current = readProjectConfig(phrenPath, project);
+    const next = {
+        ...current,
+        ...patch,
+    };
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    const tmpPath = `${configPath}.tmp-${crypto.randomUUID()}`;
+    fs.writeFileSync(tmpPath, yaml.dump(next, { lineWidth: 1000 }));
+    fs.renameSync(tmpPath, configPath);
+    return next;
+}
+export function getProjectSourcePath(phrenPath, project, config) {
+    const raw = (config ?? readProjectConfig(phrenPath, project)).sourcePath;
+    return typeof raw === "string" && raw.trim() ? path.resolve(raw) : undefined;
+}
+export function getProjectOwnershipDefault(phrenPath) {
+    return parseProjectOwnershipMode(readInstallPreferences(phrenPath).projectOwnershipDefault) ?? "phren-managed";
+}
+export function getProjectOwnershipMode(phrenPath, project, config) {
+    return parseProjectOwnershipMode((config ?? readProjectConfig(phrenPath, project)).ownership) ?? "phren-managed";
+}
+function normalizeHookConfig(config) {
+    const hooks = config?.hooks;
+    return hooks && typeof hooks === "object" ? hooks : {};
+}
+export function isProjectHookEnabled(phrenPath, project, event, config) {
+    if (!project)
+        return true;
+    const hooks = normalizeHookConfig(config ?? readProjectConfig(phrenPath, project));
+    const eventValue = hooks[event];
+    if (typeof eventValue === "boolean")
+        return eventValue;
+    if (typeof hooks.enabled === "boolean")
+        return hooks.enabled;
+    return true;
+}
+export function writeProjectHookConfig(phrenPath, project, patch) {
+    const current = readProjectConfig(phrenPath, project);
+    return writeProjectConfig(phrenPath, project, {
+        hooks: {
+            ...normalizeHookConfig(current),
+            ...patch,
+        },
+    });
+}

package/mcp/dist/project-locator.js

@@ -0,0 +1,25 @@
+import * as fs from "fs";
+import * as path from "path";
+import { debugLog, homeDir, homePath } from "./shared.js";
+import { errorMessage } from "./utils.js";
+const DEFAULT_SEARCH_PATHS = [
+    homeDir(),
+    homePath("Sites"),
+    homePath("Projects"),
+    homePath("Code"),
+    homePath("dev"),
+];
+export function findProjectDir(name) {
+    const extra = process.env.PROJECTS_DIR ? [process.env.PROJECTS_DIR] : [];
+    for (const base of [...extra, ...DEFAULT_SEARCH_PATHS]) {
+        const candidate = path.join(base, name);
+        try {
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory())
+                return candidate;
+        }
+        catch (err) {
+            debugLog(`findProjectDir: failed to check ${candidate}: ${errorMessage(err)}`);
+        }
+    }
+    return null;
+}