fathom-mcp 0.5.20 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.5.20",
+  "version": "0.6.0",
   "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "src/",
     "scripts/*.sh",
     "scripts/*.py",
+    "scripts/*.js",
     "fathom-agents.md",
     "README.md",
     "CHANGELOG.md",

package/scripts/vault-frontmatter-lint.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Vault frontmatter lint hook for Claude Code PostToolUse (Write/Edit).
+ *
+ * Reads the tool result from stdin (JSON), checks if the file is inside a
+ * vault/ directory and ends in .md. If so, validates frontmatter.
+ * Exits 0 on pass, 1 on failure (with error message on stderr).
+ *
+ * Environment: CLAUDE_TOOL_NAME, CLAUDE_FILE_PATH are set by Claude Code hooks.
+ */
+
+import fs from "fs";
+import path from "path";
+import { parseFrontmatter, validateFrontmatter } from "../src/frontmatter.js";
+
+const toolName = process.env.CLAUDE_TOOL_NAME || "";
+const filePath = process.env.CLAUDE_FILE_PATH || "";
+
+// Only check Write and Edit tools
+if (toolName !== "Write" && toolName !== "Edit") {
+  process.exit(0);
+}
+
+// Only check .md files inside a vault/ directory
+if (!filePath || !filePath.endsWith(".md")) {
+  process.exit(0);
+}
+
+// Check if the file is inside a vault/ directory
+const parts = filePath.split(path.sep);
+if (!parts.includes("vault")) {
+  process.exit(0);
+}
+
+// Read the file and validate
+try {
+  const content = fs.readFileSync(filePath, "utf-8");
+
+  // Only validate if file has frontmatter
+  if (!content.startsWith("---")) {
+    process.exit(0);
+  }
+
+  const { fm } = parseFrontmatter(content);
+  if (Object.keys(fm).length === 0) {
+    process.exit(0);
+  }
+
+  const errors = validateFrontmatter(fm);
+  if (errors.length > 0) {
+    process.stderr.write(`Vault frontmatter validation failed for ${path.basename(filePath)}:\n`);
+    for (const err of errors) {
+      process.stderr.write(`  - ${err}\n`);
+    }
+    process.exit(1);
+  }
+} catch (e) {
+  // File read errors are non-fatal for the hook
+  if (e.code !== "ENOENT") {
+    process.stderr.write(`Frontmatter lint error: ${e.message}\n`);
+  }
+}
+
+process.exit(0);

package/src/cli.js

@@ -8,13 +8,7 @@
  *   npx fathom-mcp init         — Interactive setup wizard
  *   npx fathom-mcp status       — Check server connection + workspace status
  *   npx fathom-mcp update       — Update hook scripts + version file
- *   npx fathom-mcp list         — List all agents + running status
- *   npx fathom-mcp start [name] — Start agent by name or legacy cwd-walk
- *   npx fathom-mcp stop <name>  — Stop an agent
- *   npx fathom-mcp restart <name> — Restart an agent
- *   npx fathom-mcp add [name]   — Add agent to registry (reads .fathom.json defaults)
- *   npx fathom-mcp remove <name>— Remove agent from registry
- *   npx fathom-mcp config <name>— Print agent config JSON
+ *   npx fathom-mcp list         — List workspaces + status (from server)
  */
 
 import fs from "fs";
@@ -25,17 +19,6 @@ import { fileURLToPath } from "url";
 
 import { findConfigFile, resolveConfig, writeConfig } from "./config.js";
 import { createClient } from "./server-client.js";
-import {
-  listAgents,
-  getAgent,
-  addAgent as registryAddAgent,
-  removeAgent as registryRemoveAgent,
-  isAgentRunning,
-  startAgent,
-  stopAgent,
-  defaultCommand,
-  buildEntryFromConfig,
-} from "./agents.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SCRIPTS_DIR = path.join(__dirname, "..", "scripts");
@@ -114,6 +97,33 @@ function appendToGitignore(dir, patterns) {
  * Works for both Claude Code and Gemini CLI (same JSON structure).
  * Returns true if a new hook was added, false if already present.
  */
+/**
+ * MCP tool permissions upserted into .claude/settings.local.json during init.
+ * Only fathom-vault and memento — the tools init itself provides.
+ */
+const INIT_PERMISSIONS = [
+  "mcp__fathom-vault__*",
+  "mcp__memento__*",
+];
+
+/**
+ * Upsert permissions into settings.permissions.allow.
+ * Returns true if any new entries were added.
+ */
+function ensurePermissions(settings, perms = INIT_PERMISSIONS) {
+  if (!settings.permissions) settings.permissions = {};
+  if (!Array.isArray(settings.permissions.allow)) settings.permissions.allow = [];
+  const existing = new Set(settings.permissions.allow);
+  let changed = false;
+  for (const perm of perms) {
+    if (!existing.has(perm)) {
+      settings.permissions.allow.push(perm);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 function ensureHook(settings, eventName, command, timeout) {
   const existing = settings.hooks?.[eventName] || [];
   const alreadyRegistered = existing.some((entry) =>
@@ -204,6 +214,7 @@ function parseFlags(argv) {
     server: null,
     workspace: null,
     agent: null,
+    vaultMode: null,
   };
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === "-y" || argv[i] === "--yes") {
@@ -220,6 +231,9 @@ function parseFlags(argv) {
     } else if (argv[i] === "--agent" && argv[i + 1]) {
       flags.agent = argv[i + 1];
       i++;
+    } else if (argv[i] === "--vault-mode" && argv[i + 1]) {
+      flags.vaultMode = argv[i + 1];
+      i++;
     }
   }
   // Check environment variables as fallback
@@ -295,6 +309,7 @@ async function runInit(flags = {}) {
     server: flagServer = null,
     workspace: flagWorkspace = null,
     agent: flagAgent = null,
+    vaultMode: flagVaultMode = null,
   } = flags;
   const cwd = process.cwd();
 
@@ -346,7 +361,8 @@ async function runInit(flags = {}) {
 
   let selectedAgents;
   if (nonInteractive) {
-    if (flagAgent) {
+    // In non-interactive mode, always default to claude-code unless explicitly overridden
+    if (flagAgent && flagAgent !== "claude-code") {
       if (!AGENTS[flagAgent]) {
         const valid = Object.keys(AGENTS).join(", ");
         console.error(`  Error: unknown agent "${flagAgent}". Valid agents: ${valid}`);
@@ -355,8 +371,8 @@ async function runInit(flags = {}) {
       selectedAgents = [flagAgent];
       console.log(`  Agent: ${AGENTS[flagAgent].name} (--agent flag)`);
     } else {
-      selectedAgents = detected.length > 0 ? [detected[0]] : ["claude-code"];
-      console.log(`  Agent: ${AGENTS[selectedAgents[0]].name} (auto-detected)`);
+      selectedAgents = ["claude-code"];
+      console.log(`  Agent: Claude Code`);
     }
   } else {
     console.log("\n  Detected agents:");
@@ -430,24 +446,37 @@ async function runInit(flags = {}) {
 
   // 8. Vault mode selection
   let vaultMode;
+  const validVaultModes = ["synced", "local", "none"];
   if (nonInteractive) {
     if (!serverReachable && flagServer) {
       console.error(`\n  Error: Server at ${serverUrl} is not reachable.`);
       console.error("  Fix the URL or start the server, then re-run init.");
       process.exit(1);
     }
-    vaultMode = serverReachable ? "hosted" : "local";
-    console.log(`  Vault mode: ${vaultMode} (auto-selected)`);
+    if (flagVaultMode) {
+      if (!validVaultModes.includes(flagVaultMode)) {
+        console.error(`  Error: unknown vault mode "${flagVaultMode}". Valid modes: ${validVaultModes.join(", ")}`);
+        process.exit(1);
+      }
+      if (flagVaultMode === "synced" && !serverReachable) {
+        console.error(`  Error: vault mode "${flagVaultMode}" requires a reachable server.`);
+        process.exit(1);
+      }
+      vaultMode = flagVaultMode;
+      console.log(`  Vault mode: ${vaultMode} (--vault-mode flag)`);
+    } else {
+      vaultMode = serverReachable ? "synced" : "local";
+      console.log(`  Vault mode: ${vaultMode} (auto-selected)`);
+    }
   } else {
     if (serverReachable) {
       console.log("\n  Vault mode:");
-      console.log("    1. Hosted (default) — vault stored on server, accessible everywhere");
-      console.log("    2. Synced — local vault + server mirror (local is source of truth)");
-      console.log("    3. Local — vault on disk only, not visible to server");
-      console.log("    4. None — no vault, coordination features only");
+      console.log("    1. Synced (default) — local vault + server indexing");
+      console.log("    2. Local — vault on disk only, not visible to server");
+      console.log("    3. None — no vault, coordination features only");
       const modeChoice = await ask(rl, "\n  Select mode", "1");
-      const modeMap = { "1": "hosted", "2": "synced", "3": "local", "4": "none" };
-      vaultMode = modeMap[modeChoice] || "hosted";
+      const modeMap = { "1": "synced", "2": "local", "3": "none" };
+      vaultMode = modeMap[modeChoice] || "synced";
     } else {
       console.log("\n  Vault mode (server not available — hosted/synced require server):");
       console.log("    1. Local (default) — vault on disk only");
@@ -547,15 +576,18 @@ async function runInit(flags = {}) {
   const precompactCmd = "bash ~/.config/fathom-mcp/scripts/fathom-precompact.sh";
 
   // Claude Code hooks
+  const lintCmd = "node ~/.config/fathom-mcp/scripts/vault-frontmatter-lint.js";
   if (hasClaude) {
     const settingsPath = path.join(cwd, ".claude", "settings.local.json");
     const settings = readJsonFile(settingsPath) || {};
-    let changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000);
+    let changed = ensurePermissions(settings);
+    changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
     if (enableRecallHook) changed = ensureHook(settings, "UserPromptSubmit", recallCmd, 10000) || changed;
     if (enablePrecompactHook) changed = ensureHook(settings, "PreCompact", precompactCmd, 30000) || changed;
+    changed = ensureHook(settings, "PostToolUse", lintCmd, 5000) || changed;
     if (changed) {
       writeJsonFile(settingsPath, settings);
-      console.log("  ✓ .claude/settings.local.json (hooks)");
+      console.log("  ✓ .claude/settings.local.json (permissions + hooks)");
     }
   }
 
@@ -609,11 +641,6 @@ async function runInit(flags = {}) {
     }
   }
 
-  // Register in CLI agent registry (for ls/start/stop)
-  const entry = buildEntryFromConfig(cwd, configData);
-  registryAddAgent(workspace, entry);
-  console.log(`  ✓ Registered agent "${workspace}" in CLI registry`);
-
   // Context-aware next steps
   console.log(`\n  Done! Fathom MCP is configured for workspace "${workspace}".`);
   console.log(`  Vault mode: ${vaultMode}`);
@@ -629,11 +656,8 @@ async function runInit(flags = {}) {
 
   const stepNum = serverReachable ? 1 : 2;
   switch (vaultMode) {
-    case "hosted":
-      console.log(`    ${stepNum}. Your vault is stored on the server. Start writing!`);
-      break;
     case "synced":
-      console.log(`    ${stepNum}. Local vault syncs to server. Files in ./${vault}/ are the source of truth.`);
+      console.log(`    ${stepNum}. Local vault indexed by server. Files in ./${vault}/ are the source of truth.`);
       break;
     case "local":
       console.log(`    ${stepNum}. Local vault only. Server can't search or peek into it.`);
@@ -653,6 +677,7 @@ async function runInit(flags = {}) {
     if (apiKey) parts.push(`--api-key "${apiKey}"`);
     if (serverUrl && serverUrl !== "http://localhost:4243") parts.push(`--server ${serverUrl}`);
     parts.push(`--workspace ${workspace}`);
+    parts.push(`--vault-mode ${vaultMode}`);
     parts.push(`--agent ${selectedAgents[0]}`);
     console.log(`\n  Non-interactive equivalent:\n    ${parts.join(" ")}\n`);
   }
@@ -809,7 +834,9 @@ async function runUpdate() {
   if (hasClaude) {
     const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
     const settings = readJsonFile(settingsPath) || {};
-    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+    let changed = ensurePermissions(settings);
+    changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
+    if (changed) {
       writeJsonFile(settingsPath, settings);
       registeredHooks.push("Claude Code → .claude/settings.local.json");
     }
@@ -846,70 +873,56 @@ async function runUpdate() {
   console.log("\n  Restart your agent session to pick up changes.\n");
 }
 
-// --- Start command -----------------------------------------------------------
-
-function runStart(argv) {
-  // Check if first non-flag arg matches a registry entry
-  const firstArg = argv.find((a) => !a.startsWith("-"));
-  if (firstArg) {
-    const entry = getAgent(firstArg);
-    if (entry) {
-      const result = startAgent(firstArg, entry);
-      console.log(`  ${result.message}`);
-      process.exit(result.ok ? 0 : 1);
-      return;
-    }
-  }
-
-  // Legacy fallback: delegate to fathom-start.sh
-  const found = findConfigFile(process.cwd());
-  const projectDir = found?.dir || process.cwd();
+// --- List command (via server API) --------------------------------------------
 
-  const centralScript = path.join(process.env.HOME, ".config", "fathom-mcp", "scripts", "fathom-start.sh");
-  const packageScript = path.join(SCRIPTS_DIR, "fathom-start.sh");
-  const script = fs.existsSync(centralScript) ? centralScript : packageScript;
+async function runList() {
+  const config = resolveConfig();
+  const client = createClient(config);
 
-  if (!fs.existsSync(script)) {
-    console.error("  Error: fathom-start.sh not found. Run `npx fathom-mcp update` first.");
+  const isUp = await client.healthCheck();
+  if (!isUp) {
+    console.error(`\n  Error: Server not reachable at ${config.server}`);
+    console.error("  Start the server or check --server URL.\n");
     process.exit(1);
   }
 
-  try {
-    execFileSync("bash", [script, ...argv], {
-      cwd: projectDir,
-      stdio: "inherit",
-    });
-  } catch (e) {
-    process.exit(e.status || 1);
+  const wsResult = await client.listWorkspaces();
+  if (wsResult.error) {
+    console.error(`\n  Error: ${wsResult.error}\n`);
+    process.exit(1);
   }
-}
 
-// --- List command -------------------------------------------------------------
-
-function runList() {
-  const agents = listAgents();
-  const names = Object.keys(agents);
+  const profiles = wsResult.profiles || {};
+  const names = Object.keys(profiles);
 
   if (names.length === 0) {
-    console.log("\n  No agents registered. Run `fathom-mcp add` to register one.\n");
+    console.log("\n  No workspaces registered on server.\n");
     return;
   }
 
-  // Header
-  const cols = { name: 16, type: 13, status: 10 };
+  const cols = { name: 20, type: 10, status: 12 };
   console.log(
     "\n  " +
-      "NAME".padEnd(cols.name) +
+      "WORKSPACE".padEnd(cols.name) +
       "TYPE".padEnd(cols.type) +
       "STATUS".padEnd(cols.status) +
-      "DIR",
+      "PATH",
   );
 
   for (const name of names) {
-    const entry = agents[name];
-    const type = entry.agentType || "claude-code";
-    const status = entry.ssh ? "[ssh]" : isAgentRunning(name, entry);
-    const dir = entry.projectDir.replace(process.env.HOME, "~");
+    const p = profiles[name];
+    const type = p.type || "local";
+    let status;
+    if (type === "human") {
+      status = "human";
+    } else if (p.process && p.connected) {
+      status = "running";
+    } else if (p.process || p.connected) {
+      status = "partial";
+    } else {
+      status = "stopped";
+    }
+    const dir = (p.path || "").replace(process.env.HOME, "~");
 
     console.log(
       "  " +
@@ -922,134 +935,6 @@ function runList() {
   console.log();
 }
 
-// --- Stop command ------------------------------------------------------------
-
-function runStop(name) {
-  if (!name) {
-    console.error("  Usage: fathom-mcp stop <name>");
-    process.exit(1);
-  }
-  const entry = getAgent(name);
-  if (!entry) {
-    console.error(`  Error: No agent "${name}" in registry. Run \`fathom-mcp list\` to see agents.`);
-    process.exit(1);
-  }
-  const result = stopAgent(name, entry);
-  console.log(`  ${result.message}`);
-  process.exit(result.ok ? 0 : 1);
-}
-
-// --- Restart command ---------------------------------------------------------
-
-function runRestart(name) {
-  if (!name) {
-    console.error("  Usage: fathom-mcp restart <name>");
-    process.exit(1);
-  }
-  const entry = getAgent(name);
-  if (!entry) {
-    console.error(`  Error: No agent "${name}" in registry. Run \`fathom-mcp list\` to see agents.`);
-    process.exit(1);
-  }
-
-  const stopResult = stopAgent(name, entry);
-  if (stopResult.ok) {
-    console.log(`  ${stopResult.message}`);
-  }
-
-  // Brief pause between stop and start
-  try { execFileSync("sleep", ["1"], { stdio: "pipe" }); } catch { /* */ }
-
-  const startResult = startAgent(name, entry);
-  console.log(`  ${startResult.message}`);
-  process.exit(startResult.ok ? 0 : 1);
-}
-
-// --- Add command -------------------------------------------------------------
-
-async function runAdd(argv) {
-  const flags = parseFlags(argv);
-  const nameArg = argv.find((a) => !a.startsWith("-"));
-  const cwd = process.cwd();
-
-  // Try to read .fathom.json from cwd for defaults
-  const found = findConfigFile(cwd);
-  const fathomConfig = found?.config || {};
-  const projectDir = found?.dir || cwd;
-
-  const defaults = buildEntryFromConfig(projectDir, fathomConfig);
-  const defaultName = fathomConfig.workspace || path.basename(projectDir);
-
-  if (flags.nonInteractive) {
-    const name = nameArg || defaultName;
-    registryAddAgent(name, defaults);
-    console.log(`  ✓ Added agent "${name}" to registry.`);
-    return;
-  }
-
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-  const name = await ask(rl, "  Agent name", nameArg || defaultName);
-  const agentProjectDir = await ask(rl, "  Project directory", defaults.projectDir);
-  const agentType = await ask(rl, "  Agent type (claude-code|gemini|manual)", defaults.agentType);
-  const command = await ask(rl, "  Command", defaultCommand(agentType));
-  const server = await ask(rl, "  Server URL", defaults.server);
-  const apiKey = await ask(rl, "  API key", defaults.apiKey);
-  const vault = await ask(rl, "  Vault subdirectory", defaults.vault || "vault");
-  const vaultMode = await ask(rl, "  Vault mode (hosted|synced|local|none)", defaults.vaultMode);
-  const description = await ask(rl, "  Description", defaults.description);
-
-  rl.close();
-
-  const entry = {
-    projectDir: path.resolve(agentProjectDir),
-    agentType,
-    command,
-    server,
-    apiKey,
-    vault,
-    vaultMode,
-    description,
-    hooks: defaults.hooks || {},
-    ssh: null,
-    env: {},
-  };
-
-  registryAddAgent(name, entry);
-  console.log(`\n  ✓ Added agent "${name}" to registry.`);
-}
-
-// --- Remove command ----------------------------------------------------------
-
-function runRemove(name) {
-  if (!name) {
-    console.error("  Usage: fathom-mcp remove <name>");
-    process.exit(1);
-  }
-  const removed = registryRemoveAgent(name);
-  if (removed) {
-    console.log(`  ✓ Removed agent "${name}" from registry.`);
-  } else {
-    console.error(`  Error: No agent "${name}" in registry.`);
-    process.exit(1);
-  }
-}
-
-// --- Config command ----------------------------------------------------------
-
-function runConfigCmd(name) {
-  if (!name) {
-    console.error("  Usage: fathom-mcp config <name>");
-    process.exit(1);
-  }
-  const entry = getAgent(name);
-  if (!entry) {
-    console.error(`  Error: No agent "${name}" in registry.`);
-    process.exit(1);
-  }
-  console.log(JSON.stringify({ [name]: entry }, null, 2));
-}
-
 // --- Main --------------------------------------------------------------------
 
 // Guard: only run CLI when this module is the entry point (not when imported by tests)
@@ -1071,20 +956,8 @@ if (isMain) {
     asyncHandler(runStatus);
   } else if (command === "update") {
     asyncHandler(runUpdate);
-  } else if (command === "start") {
-    runStart(process.argv.slice(3));
   } else if (command === "list" || command === "ls") {
-    runList();
-  } else if (command === "stop") {
-    runStop(process.argv[3]);
-  } else if (command === "restart") {
-    runRestart(process.argv[3]);
-  } else if (command === "add") {
-    asyncHandler(() => runAdd(process.argv.slice(3)));
-  } else if (command === "remove" || command === "rm") {
-    runRemove(process.argv[3]);
-  } else if (command === "config") {
-    runConfigCmd(process.argv[3]);
+    asyncHandler(runList);
   } else if (!command || command === "serve") {
     import("./index.js");
   } else {
@@ -1093,17 +966,10 @@ if (isMain) {
 
   fathom-mcp                                         Start MCP server (stdio)
   fathom-mcp serve                                   Same as above
-  fathom-mcp init [-y --api-key KEY --agent AGENT]    Interactive/non-interactive setup
+  fathom-mcp init [-y --api-key KEY --vault-mode MODE --agent AGENT]    Interactive/non-interactive setup
   fathom-mcp status                                  Check connection status
   fathom-mcp update                                  Update hooks + version
-
-  fathom-mcp list                                    List all agents + status
-  fathom-mcp start [name]                            Start agent (by name or legacy cwd)
-  fathom-mcp stop <name>                             Stop agent
-  fathom-mcp restart <name>                          Stop + start agent
-  fathom-mcp add [name]                              Add agent to registry
-  fathom-mcp remove <name>                           Remove from registry
-  fathom-mcp config <name>                           Print agent config JSON`);
+  fathom-mcp list                                    List workspaces + status (from server)`);
     process.exit(1);
   }
 }

package/src/config.js

@@ -4,17 +4,15 @@
  * Precedence (highest wins):
  *   1. Environment variables (FATHOM_SERVER_URL, FATHOM_API_KEY, FATHOM_WORKSPACE, FATHOM_VAULT_DIR)
  *   2. .fathom.json (walked up from cwd to filesystem root)
- *   3. Central registry (~/.config/fathom-mcp/agents.json, matched by projectDir)
- *   4. Built-in defaults
+ *   3. Built-in defaults
  */
 
 import fs from "fs";
 import path from "path";
-import { findAgentByDir } from "./agents.js";
 
 const CONFIG_FILENAME = ".fathom.json";
 
-const VALID_VAULT_MODES = new Set(["hosted", "synced", "local", "none"]);
+const VALID_VAULT_MODES = new Set(["synced", "local", "none"]);
 
 const DEFAULTS = {
   workspace: "",
@@ -76,31 +74,13 @@ function applyConfig(result, config) {
 }
 
 /**
- * Resolve final config by merging: defaults → registry → .fathom.json → env vars.
+ * Resolve final config by merging: defaults → .fathom.json → env vars.
  */
 export function resolveConfig(startDir = process.cwd()) {
   const result = { ...DEFAULTS, hooks: { ...DEFAULTS.hooks } };
   let projectDir = startDir;
 
-  // Layer 3: Central registry (matched by projectDir walk-up)
-  let registryMatch = null;
-  try {
-    registryMatch = findAgentByDir(startDir);
-  } catch {
-    // Registry not available — skip
-  }
-  if (registryMatch) {
-    const { name, entry } = registryMatch;
-    projectDir = entry.projectDir;
-    result.workspace = name;
-    applyConfig(result, entry);
-    if (entry.agentType) {
-      result.agents = [entry.agentType];
-    }
-    result._registryName = name;
-  }
-
-  // Layer 2: .fathom.json (overrides registry)
+  // Layer 2: .fathom.json
   const found = findConfigFile(startDir);
   if (found) {
     projectDir = found.dir;