@mukulaggarwal/pacman 0.1.0

package/dist/chunk-AYFIQNZ5.js

@@ -0,0 +1,807 @@
+import {
+  createIndexer
+} from "./chunk-3QNXXON5.js";
+import {
+  createNoopEventClient,
+  validateIntegrationConfig
+} from "./chunk-43PUZDIZ.js";
+import {
+  createContextManager
+} from "./chunk-UWT6AFJB.js";
+import {
+  createConfigManager,
+  createGDriveStorage,
+  createLocalStorage
+} from "./chunk-TRQIZP6Z.js";
+
+// src/mcp-installers.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MCP_SERVER_NAME = "personal_assistant";
+var DEFAULT_WORKSPACE = path.join(os.homedir(), ".personal-assistant");
+async function runCommand(command, args) {
+  const result = await execFileAsync(command, args);
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+async function resolveWorkspacePath(dirOpt) {
+  if (dirOpt) {
+    return path.resolve(dirOpt);
+  }
+  const rcPath = path.join(os.homedir(), ".personal-assistant-rc.json");
+  try {
+    const rc = JSON.parse(await fs.readFile(rcPath, "utf-8"));
+    if (rc.workspacePath) {
+      return rc.workspacePath;
+    }
+  } catch {
+  }
+  return DEFAULT_WORKSPACE;
+}
+async function resolvePacmanServerCommand() {
+  const scriptPath = path.resolve(process.argv[1]);
+  return { command: process.execPath, args: [scriptPath, "mcp", "serve"] };
+}
+async function resolveCompatServerCommand() {
+  const scriptPath = path.resolve(process.argv[1]);
+  return { command: process.execPath, args: [scriptPath] };
+}
+async function installClaudeMcp(workspacePath, resolveCommand = resolvePacmanServerCommand, runner = runCommand) {
+  const serverCommand = await resolveCommand();
+  const fallbackCommand = formatClaudeManualInstallCommand(workspacePath, serverCommand);
+  try {
+    try {
+      await runner("claude", ["mcp", "remove", "-s", "user", MCP_SERVER_NAME]);
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+      if (code === "ENOENT") {
+        throw err;
+      }
+    }
+    await runner("claude", [
+      "mcp",
+      "add",
+      "-s",
+      "user",
+      `--env=PA_WORKSPACE=${workspacePath}`,
+      MCP_SERVER_NAME,
+      "--",
+      serverCommand.command,
+      ...serverCommand.args
+    ]);
+  } catch (err) {
+    throw normalizeClaudeInstallError(err, fallbackCommand);
+  }
+}
+function formatClaudeManualInstallCommand(workspacePath, serverCommand) {
+  return [
+    "claude",
+    "mcp",
+    "add",
+    "-s",
+    "user",
+    `--env=${shellQuote(`PA_WORKSPACE=${workspacePath}`)}`,
+    MCP_SERVER_NAME,
+    "--",
+    shellQuote(serverCommand.command),
+    ...serverCommand.args.map(shellQuote)
+  ].join(" ");
+}
+function formatCodexManualInstallCommand(workspacePath, serverCommand) {
+  return [
+    "codex",
+    "mcp",
+    "add",
+    MCP_SERVER_NAME,
+    "--env",
+    shellQuote(`PA_WORKSPACE=${workspacePath}`),
+    "--",
+    shellQuote(serverCommand.command),
+    ...serverCommand.args.map(shellQuote)
+  ].join(" ");
+}
+function parseCodexServerList(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const jsonStart = trimmed.indexOf("[");
+  const json = jsonStart >= 0 ? trimmed.slice(jsonStart) : trimmed;
+  return JSON.parse(json);
+}
+async function installCodexMcp(workspacePath, resolveCommand = resolvePacmanServerCommand, runner = runCommand) {
+  const serverCommand = await resolveCommand();
+  const fallbackCommand = formatCodexManualInstallCommand(workspacePath, serverCommand);
+  try {
+    const { stdout } = await runner("codex", ["mcp", "list", "--json"]);
+    const servers = parseCodexServerList(stdout);
+    if (servers.some((server) => server.name === MCP_SERVER_NAME)) {
+      await runner("codex", ["mcp", "remove", MCP_SERVER_NAME]);
+    }
+    await runner("codex", [
+      "mcp",
+      "add",
+      MCP_SERVER_NAME,
+      "--env",
+      `PA_WORKSPACE=${workspacePath}`,
+      "--",
+      serverCommand.command,
+      ...serverCommand.args
+    ]);
+  } catch (err) {
+    throw normalizeCodexInstallError(err, fallbackCommand);
+  }
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:=+-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function normalizeCodexInstallError(err, fallbackCommand) {
+  const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+  const stderr = typeof err === "object" && err !== null && "stderr" in err ? String(err.stderr ?? "") : "";
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "ENOENT") {
+    return new Error(
+      `Codex CLI was not found on PATH. Install Codex, then rerun \`pacman mcp codex install\`. Manual registration once Codex is available: \`${fallbackCommand}\``
+    );
+  }
+  const details = stderr.trim() || message;
+  return new Error(
+    `Unable to register the Personal Assistant MCP server with Codex. ${details} Manual fallback: \`${fallbackCommand}\``
+  );
+}
+function normalizeClaudeInstallError(err, fallbackCommand) {
+  const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+  const stderr = typeof err === "object" && err !== null && "stderr" in err ? String(err.stderr ?? "") : "";
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "ENOENT") {
+    return new Error(
+      `Claude Code CLI was not found on PATH. Install Claude Code, then rerun \`pacman mcp claude install\`. Manual registration once Claude Code is available: \`${fallbackCommand}\``
+    );
+  }
+  const details = stderr.trim() || message;
+  return new Error(
+    `Unable to register the Personal Assistant MCP server with Claude Code. ${details} Manual fallback: \`${fallbackCommand}\``
+  );
+}
+
+// src/mcp-server.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var DEFAULT_RESTART_STEPS = [
+  "Restart your MCP client after the configuration has been updated.",
+  "If the registered workspace path changed, rerun `pacman mcp claude install` for Claude Code or `pacman mcp codex install` for Codex before restarting."
+];
+async function startMcpServer(workspacePath) {
+  const localStore = createLocalStorage(workspacePath);
+  let storage = localStore;
+  let configManager = createConfigManager(localStore);
+  let contextManager = createContextManager(localStore);
+  let indexer = createIndexer(localStore);
+  const eventClient = createNoopEventClient();
+  let bootstrapConfig = null;
+  let storageReadyResolve;
+  const storageReady = new Promise((resolve3) => {
+    storageReadyResolve = resolve3;
+  });
+  const runtimeHealth = {
+    storage: {
+      status: "healthy",
+      mode: "local",
+      summary: `Using local workspace at ${workspacePath}`,
+      fix: [],
+      restart: DEFAULT_RESTART_STEPS
+    },
+    integrations: [],
+    alerts: []
+  };
+  const server = new McpServer({
+    name: "personal-assistant",
+    version: "0.1.0"
+  });
+  function textResult(text, isError = false) {
+    return {
+      content: [{ type: "text", text }],
+      ...isError ? { isError: true } : {}
+    };
+  }
+  function getStatusConfig() {
+    return bootstrapConfig ?? {
+      user: { name: "", assistantName: "Jarvis", profileType: "software-engineer", responsibilities: [] },
+      storage: { mode: "local", workspacePath },
+      integrations: [],
+      sync: {
+        dailySyncTime: "09:00",
+        timezone: "UTC",
+        manualSyncEnabled: false,
+        asyncUpdateEnabled: false
+      }
+    };
+  }
+  function addAlert(alert) {
+    runtimeHealth.alerts.push(alert);
+  }
+  function setStorageFailure(mode, reason, fix) {
+    runtimeHealth.storage = {
+      status: "error",
+      mode,
+      summary: `Unable to use ${mode} storage`,
+      reason,
+      fix,
+      restart: DEFAULT_RESTART_STEPS
+    };
+    addAlert({
+      component: "storage",
+      name: mode,
+      reason,
+      fix,
+      restart: DEFAULT_RESTART_STEPS
+    });
+  }
+  function formatSteps(label, steps) {
+    if (steps.length === 0) return "";
+    return `${label}:
+${steps.map((step, index) => `${index + 1}. ${step}`).join("\n")}`;
+  }
+  function storageUnavailableMessage() {
+    const sections = [
+      `Personal Assistant MCP storage is unavailable: ${runtimeHealth.storage.reason ?? runtimeHealth.storage.summary}`,
+      formatSteps("Fix", runtimeHealth.storage.fix),
+      formatSteps("Restart", runtimeHealth.storage.restart)
+    ].filter(Boolean);
+    return sections.join("\n\n");
+  }
+  function logStartupHealth() {
+    if (runtimeHealth.alerts.length === 0) {
+      console.error(`Personal Assistant MCP ready. Storage: ${runtimeHealth.storage.mode}`);
+      return;
+    }
+    console.error("Personal Assistant MCP startup alerts:");
+    for (const alert of runtimeHealth.alerts) {
+      console.error(`- ${alert.component} ${alert.name}: ${alert.reason}`);
+      for (const step of alert.fix) {
+        console.error(`  Fix: ${step}`);
+      }
+      for (const step of alert.restart) {
+        console.error(`  Restart: ${step}`);
+      }
+    }
+  }
+  function getStorageFixSteps(mode, config) {
+    if (mode === "gdrive") {
+      return [
+        "Verify the Google Drive folder ID and OAuth credentials in profile/storage.json.",
+        "If the refresh token is no longer valid, reconnect Google Drive and save the updated configuration.",
+        ...config?.cachePath ? [`Ensure the local cache path exists and is writable: ${config.cachePath}`] : []
+      ];
+    }
+    return [
+      `Verify that PA_WORKSPACE points to the correct workspace directory: ${workspacePath}`,
+      "Ensure the workspace directory exists and is writable.",
+      "Run `pacman init` if the workspace has not been initialized yet."
+    ];
+  }
+  function getIntegrationHealth(type) {
+    return runtimeHealth.integrations.find((integration) => integration.type === type);
+  }
+  async function ensureStorageAvailable() {
+    await storageReady;
+    if (runtimeHealth.storage.status === "error") {
+      return textResult(storageUnavailableMessage(), true);
+    }
+    return null;
+  }
+  async function resolveStorageBackend() {
+    bootstrapConfig = await configManager.loadConfig();
+    runtimeHealth.storage.mode = bootstrapConfig.storage.mode;
+    if (bootstrapConfig.storage.mode === "gdrive") {
+      const gdriveConfig = bootstrapConfig.storage;
+      const resolvedCachePath = path2.isAbsolute(gdriveConfig.cachePath) ? gdriveConfig.cachePath : path2.resolve(path2.dirname(workspacePath), gdriveConfig.cachePath);
+      try {
+        const gdriveStorage = createGDriveStorage({
+          ...gdriveConfig,
+          cachePath: resolvedCachePath
+        });
+        await gdriveStorage.initialize();
+        storage = gdriveStorage;
+        configManager = createConfigManager(gdriveStorage);
+        contextManager = createContextManager(gdriveStorage);
+        indexer = createIndexer(gdriveStorage);
+        bootstrapConfig = await configManager.loadConfig();
+        runtimeHealth.storage = {
+          status: "healthy",
+          mode: "gdrive",
+          summary: `Connected to Google Drive storage${gdriveConfig.folderName ? ` (${gdriveConfig.folderName})` : ""}`,
+          fix: [],
+          restart: DEFAULT_RESTART_STEPS
+        };
+      } catch (err) {
+        setStorageFailure(
+          "gdrive",
+          err instanceof Error ? err.message : String(err),
+          getStorageFixSteps("gdrive", {
+            ...gdriveConfig,
+            cachePath: resolvedCachePath
+          })
+        );
+      }
+    } else {
+      try {
+        await fs2.mkdir(workspacePath, { recursive: true });
+        runtimeHealth.storage = {
+          status: "healthy",
+          mode: "local",
+          summary: `Using local workspace at ${workspacePath}`,
+          fix: [],
+          restart: DEFAULT_RESTART_STEPS
+        };
+      } catch (err) {
+        setStorageFailure(
+          "local",
+          err instanceof Error ? err.message : String(err),
+          getStorageFixSteps("local")
+        );
+      }
+    }
+    const configForIntegrations = getStatusConfig();
+    runtimeHealth.integrations = [];
+    for (const integration of configForIntegrations.integrations.filter((item) => item.enabled)) {
+      const result = await validateIntegrationConfig(integration);
+      if (result.ok) {
+        runtimeHealth.integrations.push({
+          type: integration.type,
+          status: "healthy",
+          summary: result.summary ?? `Connected to ${integration.type}`,
+          fix: [],
+          restart: DEFAULT_RESTART_STEPS
+        });
+        continue;
+      }
+      runtimeHealth.integrations.push({
+        type: integration.type,
+        status: "error",
+        summary: `Unable to connect to ${integration.type}`,
+        reason: result.reason ?? `Unable to connect to ${integration.type}`,
+        fix: result.fix ?? [],
+        restart: DEFAULT_RESTART_STEPS
+      });
+      addAlert({
+        component: "integration",
+        name: integration.type,
+        reason: result.reason ?? `Unable to connect to ${integration.type}`,
+        fix: result.fix ?? [],
+        restart: DEFAULT_RESTART_STEPS
+      });
+    }
+    logStartupHealth();
+  }
+  server.tool("config_get", "Get the full application configuration", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      const config = await configManager.loadConfig();
+      return textResult(JSON.stringify(config, null, 2));
+    } catch (err) {
+      return textResult(`Error loading config: ${err}`, true);
+    }
+  });
+  server.tool("config_get_storage_mode", "Get the current storage mode (local or gdrive)", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      const mode = await configManager.getStorageMode();
+      return textResult(mode);
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool("config_get_active_project", "Get the currently active project name", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      const project = await configManager.getActiveProject();
+      return textResult(project ?? "No active project set");
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool(
+    "config_set_active_project",
+    "Set the active project",
+    { project_name: z.string().describe("The project name to set as active") },
+    async ({ project_name }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        await configManager.setActiveProject(project_name);
+        await eventClient.emitWithProject("project_selected", project_name);
+        return textResult(`Active project set to: ${project_name}`);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool("project_list", "List all known projects", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      const projects = await contextManager.listProjects();
+      return textResult(projects.length > 0 ? projects.join("\n") : "No projects found");
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool(
+    "project_suggest",
+    "Suggest a project based on context",
+    {
+      hint: z.string().optional().describe("Optional hint to narrow project suggestion")
+    },
+    async ({ hint }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const suggestion = await contextManager.suggestProject(hint);
+        if (!suggestion) {
+          return textResult("No projects found to suggest");
+        }
+        return textResult(JSON.stringify(suggestion, null, 2));
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "project_get_context",
+    "Get the full context for a project",
+    { project_name: z.string().describe("The project name") },
+    async ({ project_name }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const context = await contextManager.getProjectContext(project_name);
+        await eventClient.emit("mcp_query_executed", { tool: "project_get_context" });
+        const parts = [];
+        parts.push(`# Project: ${context.name}
+`);
+        for (const file of context.canonicalFiles) {
+          parts.push(`## ${file.path}
+${file.content}
+`);
+        }
+        for (const file of context.derivedFiles) {
+          if (file.path.endsWith(".json")) {
+            parts.push(`## ${file.path}
+\`\`\`json
+${file.content.slice(0, 2e3)}
+\`\`\`
+`);
+          } else {
+            parts.push(`## ${file.path}
+${file.content}
+`);
+          }
+        }
+        return textResult(parts.join("\n"));
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_search",
+    "Search across all context files",
+    { query: z.string().describe("Search query") },
+    async ({ query }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const results = await indexer.search(query);
+        await eventClient.emit("mcp_query_executed", { tool: "context_search" });
+        if (results.length === 0) {
+          return textResult("No results found");
+        }
+        const text = results.map(
+          (result) => `[${result.matchType}] ${result.filePath}${result.section ? ` > ${result.section}` : ""} (score: ${result.score})
+${result.content}
+`
+        ).join("\n---\n");
+        return textResult(text);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_read_file",
+    "Read a specific context file",
+    { file_path: z.string().describe("Path to the context file") },
+    async ({ file_path }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const content = await contextManager.readFile(file_path);
+        return textResult(content);
+      } catch (err) {
+        return textResult(`Error reading file: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_read_section",
+    "Read a specific section from a context file",
+    {
+      file_path: z.string().describe("Path to the context file"),
+      section_name: z.string().describe("Name of the section to read")
+    },
+    async ({ file_path, section_name }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const section = await contextManager.readSection(file_path, section_name);
+        if (!section) {
+          return textResult(`Section "${section_name}" not found in ${file_path}`);
+        }
+        return textResult(section);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_list_recent_updates",
+    "List recent context update proposals",
+    { limit: z.number().optional().describe("Maximum number of updates to return") },
+    async ({ limit }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const updates = await contextManager.listRecentUpdates(limit ?? 10);
+        if (updates.length === 0) {
+          return textResult("No recent updates");
+        }
+        return textResult(JSON.stringify(updates, null, 2));
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_get_daily_summary",
+    "Get the daily summary for a specific date",
+    { date: z.string().optional().describe("Date in YYYY-MM-DD format (defaults to today)") },
+    async ({ date }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const summary = await contextManager.getDailySummary(date);
+        if (!summary) {
+          return textResult(`No daily summary found for ${date ?? "today"}`);
+        }
+        return textResult(summary);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_propose_update",
+    "Propose an update to a context file",
+    {
+      target_file: z.string().describe("Path to the target file"),
+      section: z.string().optional().describe("Section name to update (omit for full file)"),
+      proposed_content: z.string().describe("The proposed new content"),
+      reason: z.string().describe("Reason for the update")
+    },
+    async ({ target_file, section, proposed_content, reason }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const proposal = await contextManager.proposeUpdate({
+          targetFile: target_file,
+          section,
+          proposedContent: proposed_content,
+          reason
+        });
+        await eventClient.emit("context_update_proposed");
+        return textResult(
+          `Update proposal created: ${proposal.id}
+Target: ${proposal.targetFile}
+Reason: ${proposal.reason}
+Status: ${proposal.status}`
+        );
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_apply_update",
+    "Apply a pending update proposal",
+    { proposal_id: z.string().describe("ID of the proposal to apply") },
+    async ({ proposal_id }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const applied = await contextManager.applyUpdate(proposal_id);
+        await eventClient.emit("context_update_applied");
+        return textResult(
+          `Update applied: ${applied.id}
+Target: ${applied.targetFile}
+Applied at: ${applied.appliedAt}`
+        );
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool(
+    "context_append_note",
+    "Append a note to a project context file",
+    {
+      project_name: z.string().describe("The project name"),
+      note: z.string().describe("The note to append")
+    },
+    async ({ project_name, note }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        await contextManager.appendNote(project_name, note);
+        return textResult(`Note appended to project: ${project_name}`);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  server.tool("context_rebuild_indexes", "Rebuild all context indexes", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      await indexer.buildIndexes();
+      return textResult("Indexes rebuilt successfully");
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool(
+    "session_end",
+    "End the current session: force-apply all pending proposals, save session notes, rebuild indexes, and clear the active project",
+    {
+      project_name: z.string().optional().describe("The active project name"),
+      session_notes: z.string().optional().describe("Summary of what was learned or decided during this session")
+    },
+    async ({ project_name, session_notes }) => {
+      const unavailable = await ensureStorageAvailable();
+      if (unavailable) return unavailable;
+      try {
+        const results = [];
+        const appliedIds = await contextManager.applyAllPending();
+        if (appliedIds.length > 0) {
+          results.push(`Applied ${appliedIds.length} pending proposal(s): ${appliedIds.join(", ")}`);
+        } else {
+          results.push("No pending proposals to apply.");
+        }
+        if (session_notes && project_name) {
+          await contextManager.appendNote(project_name, session_notes);
+          results.push(`Session notes saved to project: ${project_name}`);
+        }
+        await indexer.buildIndexes();
+        results.push("Indexes rebuilt.");
+        await configManager.setActiveProject("");
+        results.push("Active project cleared.");
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const logEntry = `[${timestamp}] Session ended for project "${project_name ?? "none"}". Applied ${appliedIds.length} proposals.
+`;
+        await storage.append("logs/audit.log", logEntry);
+        return textResult(`Session ended successfully.
+
+${results.join("\n")}`);
+      } catch (err) {
+        return textResult(`Error ending session: ${err}`, true);
+      }
+    }
+  );
+  server.tool("sync_run_now", "Trigger an immediate sync", {}, async () => {
+    const unavailable = await ensureStorageAvailable();
+    if (unavailable) return unavailable;
+    try {
+      await indexer.buildIndexes();
+      return textResult("Sync completed. Indexes rebuilt.");
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool("sync_status", "Get the current sync status", {}, async () => {
+    await storageReady;
+    try {
+      const config = getStatusConfig();
+      const integrations = config.integrations.filter((integration) => integration.enabled).map((integration) => {
+        const health = getIntegrationHealth(integration.type);
+        return {
+          type: integration.type,
+          lastSyncAt: integration.lastSyncAt ?? "never",
+          cursor: integration.cursor ?? "none",
+          connectionStatus: health?.status ?? "healthy",
+          connectionSummary: health?.summary ?? `No startup health check recorded for ${integration.type}`,
+          connectionReason: health?.reason ?? null,
+          fix: health?.fix ?? [],
+          restart: health?.restart ?? DEFAULT_RESTART_STEPS
+        };
+      });
+      const status = {
+        syncTime: config.sync.dailySyncTime,
+        timezone: config.sync.timezone,
+        storage: {
+          mode: runtimeHealth.storage.mode,
+          status: runtimeHealth.storage.status,
+          summary: runtimeHealth.storage.summary,
+          reason: runtimeHealth.storage.reason ?? null,
+          fix: runtimeHealth.storage.fix,
+          restart: runtimeHealth.storage.restart
+        },
+        integrations,
+        alerts: runtimeHealth.alerts
+      };
+      return textResult(JSON.stringify(status, null, 2));
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool("sync_list_integrations", "List all configured integrations", {}, async () => {
+    await storageReady;
+    try {
+      const config = getStatusConfig();
+      const list = config.integrations.map((integration) => {
+        const health = getIntegrationHealth(integration.type);
+        const connection = health ? health.status === "healthy" ? `healthy - ${health.summary}` : `error - ${health.reason ?? health.summary}` : "not checked";
+        return `${integration.type}: ${integration.enabled ? "enabled" : "disabled"} (connection: ${connection}; last sync: ${integration.lastSyncAt ?? "never"})`;
+      });
+      return textResult(list.join("\n") || "No integrations configured");
+    } catch (err) {
+      return textResult(`Error: ${err}`, true);
+    }
+  });
+  server.tool(
+    "events_ping",
+    "Emit a metadata-only event",
+    {
+      event_name: z.string().describe("Name of the event"),
+      metadata: z.record(z.string()).optional().describe("Optional metadata key-value pairs")
+    },
+    async ({ event_name, metadata }) => {
+      await storageReady;
+      try {
+        await eventClient.emit(event_name, metadata);
+        return textResult(`Event emitted: ${event_name}`);
+      } catch (err) {
+        return textResult(`Error: ${err}`, true);
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  await resolveStorageBackend();
+  storageReadyResolve?.();
+}
+
+export {
+  DEFAULT_WORKSPACE,
+  resolveWorkspacePath,
+  resolvePacmanServerCommand,
+  resolveCompatServerCommand,
+  installClaudeMcp,
+  installCodexMcp,
+  startMcpServer
+};
+//# sourceMappingURL=chunk-AYFIQNZ5.js.map