fifony 0.1.11

package/dist/mcp/server.js

@@ -0,0 +1,747 @@
+import {
+  inferCapabilityPaths,
+  renderPrompt,
+  resolveTaskCapabilities
+} from "../chunk-LH5V2WV2.js";
+
+// src/mcp/server.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { dirname, join as join3, resolve as resolve3 } from "path";
+import { env as env2, stdin, stdout } from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/integrations/catalog.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function listNames(basePath) {
+  if (!existsSync(basePath)) {
+    return [];
+  }
+  return readdirSync(basePath, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isFile()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+}
+function readSkillSummary(skillPath) {
+  try {
+    const skillFile = join(skillPath, "SKILL.md");
+    if (!existsSync(skillFile)) {
+      return "";
+    }
+    const contents = readFileSync(skillFile, "utf8");
+    const firstParagraph = contents.split("\n").map((line) => line.trim()).filter(Boolean).find((line) => !line.startsWith("#"));
+    return firstParagraph ?? "";
+  } catch {
+    return "";
+  }
+}
+function discoverIntegrations(workspaceRoot) {
+  const home = homedir();
+  const agentLocations = [
+    resolve(workspaceRoot, ".codex", "agents"),
+    resolve(workspaceRoot, "agents"),
+    join(home, ".codex", "agents"),
+    join(home, ".claude", "agents")
+  ];
+  const skillLocations = [
+    resolve(workspaceRoot, ".codex", "skills"),
+    resolve(workspaceRoot, ".claude", "skills"),
+    join(home, ".codex", "skills"),
+    join(home, ".claude", "skills")
+  ];
+  const agencyItems = agentLocations.flatMap((location) => listNames(location).map((name) => ({ location, name }))).filter(({ name }) => name.startsWith("agency-")).map(({ location, name }) => `${name} @ ${location}`);
+  const impeccableItems = skillLocations.flatMap((location) => listNames(location).map((name) => ({ location, name }))).filter(
+    ({ name }) => name === "teach-impeccable" || name === "frontend-design" || name === "polish" || name === "audit" || name === "critique" || name.includes("impeccable")
+  ).map(({ location, name }) => {
+    const summary = readSkillSummary(join(location, name));
+    return summary ? `${name} @ ${location} \u2014 ${summary}` : `${name} @ ${location}`;
+  });
+  return [
+    {
+      id: "agency-agents",
+      kind: "agents",
+      installed: agencyItems.length > 0,
+      locations: agentLocations.filter((location) => existsSync(location)),
+      items: agencyItems,
+      summary: agencyItems.length > 0 ? "Local specialized agent profiles are available for planner/executor/reviewer roles." : "No agency agent profiles were detected in the standard local locations."
+    },
+    {
+      id: "impeccable",
+      kind: "skills",
+      installed: impeccableItems.length > 0,
+      locations: skillLocations.filter((location) => existsSync(location)),
+      items: impeccableItems,
+      summary: impeccableItems.length > 0 ? "Frontend and design-oriented skills are available for review and polish workflows." : "No impeccable-related skills were detected in the standard local skill directories."
+    }
+  ];
+}
+async function buildIntegrationSnippet(integrationId, workspaceRoot) {
+  if (integrationId === "agency-agents") {
+    return renderPrompt("integrations-agency-agents", { workspaceRoot });
+  }
+  if (integrationId === "impeccable") {
+    return renderPrompt("integrations-impeccable");
+  }
+  return "Unknown integration.";
+}
+
+// src/mcp/database.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { basename, join as join2, resolve as resolve2 } from "path";
+import { env } from "process";
+import { homedir as homedir2 } from "os";
+import { fileURLToPath } from "url";
+var WORKSPACE_ROOT = env.FIFONY_WORKSPACE_ROOT ?? process.cwd();
+var PERSISTENCE_ROOT = env.FIFONY_PERSISTENCE ?? WORKSPACE_ROOT;
+var STATE_ROOT = resolvePersistenceRoot(PERSISTENCE_ROOT);
+var DATABASE_PATH = join2(STATE_ROOT, "s3db");
+var STORAGE_BUCKET = env.FIFONY_STORAGE_BUCKET ?? "fifony";
+var STORAGE_KEY_PREFIX = env.FIFONY_STORAGE_KEY_PREFIX ?? "state";
+var DEBUG_BOOT = env.FIFONY_DEBUG_BOOT === "1";
+function resolvePersistenceRoot(value) {
+  const resolved = value.startsWith("file://") ? fileURLToPath(value) : value.startsWith("~/") ? resolve2(homedir2(), value.slice(2)) : resolve2(value);
+  return basename(resolved) === ".fifony" ? resolved : join2(resolved, ".fifony");
+}
+var RUNTIME_RESOURCE = "runtime_state";
+var ISSUE_RESOURCE = "issues";
+var EVENT_RESOURCE = "events";
+var SESSION_RESOURCE = "agent_sessions";
+var PIPELINE_RESOURCE = "agent_pipelines";
+var RUNTIME_RECORD_ID = "current";
+var database = null;
+var runtimeResource = null;
+var issueResource = null;
+var eventResource = null;
+var sessionResource = null;
+var pipelineResource = null;
+function getResources() {
+  return { runtimeResource, issueResource, eventResource, sessionResource, pipelineResource };
+}
+function getDatabase() {
+  return database;
+}
+function debugBoot(message) {
+  if (!DEBUG_BOOT) return;
+  process.stderr.write(`[FIFONY_DEBUG_BOOT] ${message}
+`);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function safeRead(path) {
+  return existsSync2(path) ? readFileSync2(path, "utf8") : "";
+}
+async function loadS3dbModule() {
+  try {
+    const imported = await import("s3db.js/lite");
+    return {
+      default: imported.default,
+      FileSystemClient: imported.FileSystemClient
+    };
+  } catch (error) {
+    throw new Error(`Unable to load s3db.js: ${String(error)}`);
+  }
+}
+async function initDatabase() {
+  if (database) return database;
+  debugBoot("mcp:getDatabase:start");
+  const s3db = await loadS3dbModule();
+  debugBoot("mcp:getDatabase:module-loaded");
+  const client = new s3db.FileSystemClient({
+    basePath: DATABASE_PATH,
+    bucket: STORAGE_BUCKET,
+    keyPrefix: STORAGE_KEY_PREFIX,
+    verbose: false
+  });
+  database = new s3db.default({ client, verbose: false });
+  await database.connect();
+  debugBoot("mcp:getDatabase:connected");
+  runtimeResource = database.resources[RUNTIME_RESOURCE] ?? await database.createResource({
+    name: RUNTIME_RESOURCE,
+    behavior: "body-overflow",
+    attributes: {
+      updatedAt: "datetime|required",
+      state: "json|required"
+    }
+  });
+  issueResource = database.resources[ISSUE_RESOURCE] ?? await database.createResource({
+    name: ISSUE_RESOURCE,
+    behavior: "body-overflow",
+    attributes: {
+      id: "string|required",
+      identifier: "string|required",
+      title: "string|required",
+      description: "string|optional",
+      priority: "number|required",
+      state: "string|required",
+      branchName: "string|optional",
+      labels: "json|required",
+      paths: "json|optional",
+      inferredPaths: "json|optional",
+      capabilityCategory: "string|optional",
+      capabilityOverlays: "json|optional",
+      capabilityRationale: "json|optional",
+      blockedBy: "json|required",
+      assignedToWorker: "boolean|required",
+      createdAt: "datetime|required",
+      updatedAt: "datetime|required",
+      history: "json|required",
+      attempts: "number|required",
+      maxAttempts: "number|required",
+      url: "string|optional",
+      assigneeId: "string|optional",
+      startedAt: "datetime|optional",
+      completedAt: "datetime|optional",
+      nextRetryAt: "datetime|optional",
+      workspacePath: "string|optional",
+      workspacePreparedAt: "datetime|optional",
+      lastError: "string|optional",
+      durationMs: "number|optional",
+      commandExitCode: "number|optional",
+      commandOutputTail: "string|optional"
+    },
+    partitions: {
+      byState: { fields: { state: "string" } },
+      byCapabilityCategory: { fields: { capabilityCategory: "string" } },
+      byStateAndCapability: {
+        fields: { state: "string", capabilityCategory: "string" }
+      }
+    },
+    asyncPartitions: true
+  });
+  eventResource = database.resources[EVENT_RESOURCE] ?? await database.createResource({
+    name: EVENT_RESOURCE,
+    behavior: "body-overflow",
+    attributes: {
+      id: "string|required",
+      issueId: "string|optional",
+      kind: "string|required",
+      message: "string|required",
+      at: "datetime|required"
+    },
+    partitions: {
+      byIssueId: { fields: { issueId: "string" } },
+      byKind: { fields: { kind: "string" } },
+      byIssueIdAndKind: { fields: { issueId: "string", kind: "string" } }
+    },
+    asyncPartitions: true
+  });
+  sessionResource = database.resources[SESSION_RESOURCE] ?? await database.createResource({
+    name: SESSION_RESOURCE,
+    behavior: "body-overflow",
+    attributes: {
+      id: "string|required",
+      issueId: "string|required",
+      issueIdentifier: "string|required",
+      attempt: "number|required",
+      provider: "string|required",
+      role: "string|required",
+      cycle: "number|required",
+      session: "json|required",
+      updatedAt: "datetime|required"
+    },
+    partitions: {
+      byIssueId: { fields: { issueId: "string" } },
+      byIssueAttempt: { fields: { issueId: "string", attempt: "number" } },
+      byProviderRole: { fields: { provider: "string", role: "string" } }
+    },
+    asyncPartitions: true
+  });
+  pipelineResource = database.resources[PIPELINE_RESOURCE] ?? await database.createResource({
+    name: PIPELINE_RESOURCE,
+    behavior: "body-overflow",
+    attributes: {
+      id: "string|required",
+      issueId: "string|required",
+      issueIdentifier: "string|required",
+      attempt: "number|required",
+      pipeline: "json|required",
+      updatedAt: "datetime|required"
+    },
+    partitions: {
+      byIssueId: { fields: { issueId: "string" } },
+      byIssueAttempt: { fields: { issueId: "string", attempt: "number" } }
+    },
+    asyncPartitions: true
+  });
+  debugBoot("mcp:getDatabase:resources-ready");
+  return database;
+}
+async function listRecords(resource, limit = 100) {
+  if (!resource) return [];
+  if (typeof resource.query === "function") return await resource.query({});
+  return await resource.list({ limit });
+}
+async function listIssues(filters = {}) {
+  await initDatabase();
+  const { state, capabilityCategory } = filters;
+  if (!issueResource) return [];
+  const partition = state && capabilityCategory ? "byStateAndCapability" : state ? "byState" : capabilityCategory ? "byCapabilityCategory" : null;
+  const partitionValues = state && capabilityCategory ? { state, capabilityCategory } : state ? { state } : capabilityCategory ? { capabilityCategory } : {};
+  const records = await issueResource.list({ partition, partitionValues, limit: 500 });
+  return records.map((record) => record);
+}
+async function listEvents(filters = {}) {
+  await initDatabase();
+  const { issueId, kind, limit = 100 } = filters;
+  if (!eventResource) return [];
+  const partition = issueId && kind ? "byIssueIdAndKind" : issueId ? "byIssueId" : kind ? "byKind" : null;
+  const partitionValues = issueId && kind ? { issueId, kind } : issueId ? { issueId } : kind ? { kind } : {};
+  return await eventResource.list({ partition, partitionValues, limit });
+}
+async function getRuntimeSnapshot() {
+  await initDatabase();
+  const record = await runtimeResource?.get(RUNTIME_RECORD_ID);
+  const state = record?.state;
+  if (state && typeof state === "object") return state;
+  return {};
+}
+async function getIssues() {
+  return await listIssues();
+}
+async function getIssue(issueId) {
+  await initDatabase();
+  const issue = await issueResource?.get(issueId);
+  return issue ?? null;
+}
+async function appendEvent(level, message, payload = {}, issueId) {
+  await initDatabase();
+  const { randomUUID } = await import("crypto");
+  await eventResource?.insert({
+    id: randomUUID(),
+    issueId,
+    kind: level,
+    message,
+    at: nowIso()
+  });
+}
+
+// src/mcp/server.ts
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname(__filename);
+var PACKAGE_ROOT = resolve3(__dirname, "../..");
+var WORKFLOW_PATH = join3(WORKSPACE_ROOT, "WORKFLOW.md");
+var README_PATH = join3(PACKAGE_ROOT, "README.md");
+var FIFONY_GUIDE_PATH = join3(PACKAGE_ROOT, "FIFONY.md");
+var DEBUG_BOOT2 = env2.FIFONY_DEBUG_BOOT === "1";
+var incomingBuffer = Buffer.alloc(0);
+function debugBoot2(message) {
+  if (!DEBUG_BOOT2) return;
+  process.stderr.write(`[FIFONY_DEBUG_BOOT] ${message}
+`);
+}
+function hashInput(value) {
+  return createHash("sha1").update(value).digest("hex").slice(0, 10);
+}
+async function buildIntegrationGuide() {
+  return renderPrompt("mcp-integration-guide", {
+    workspaceRoot: WORKSPACE_ROOT,
+    persistenceRoot: PERSISTENCE_ROOT,
+    stateRoot: STATE_ROOT
+  });
+}
+function computeCapabilityCounts(issues) {
+  return issues.reduce((accumulator, issue) => {
+    const key = typeof issue.capabilityCategory === "string" && issue.capabilityCategory.trim() ? issue.capabilityCategory.trim() : "default";
+    accumulator[key] = (accumulator[key] ?? 0) + 1;
+    return accumulator;
+  }, {});
+}
+async function buildStateSummary() {
+  const runtime = await getRuntimeSnapshot();
+  const issues = await getIssues();
+  const { sessionResource: sessionResource2, pipelineResource: pipelineResource2 } = getResources();
+  const sessions = await listRecords(sessionResource2, 500);
+  const pipelines = await listRecords(pipelineResource2, 500);
+  const events = await listEvents({ limit: 100 });
+  const byState = issues.reduce((accumulator, issue) => {
+    const key = issue.state ?? "Unknown";
+    accumulator[key] = (accumulator[key] ?? 0) + 1;
+    return accumulator;
+  }, {});
+  const byCapability = computeCapabilityCounts(issues);
+  return JSON.stringify({
+    workspaceRoot: WORKSPACE_ROOT,
+    persistenceRoot: PERSISTENCE_ROOT,
+    stateRoot: STATE_ROOT,
+    workflowPresent: existsSync3(WORKFLOW_PATH),
+    runtimeUpdatedAt: runtime.updatedAt ?? null,
+    issueCount: issues.length,
+    issuesByState: byState,
+    issuesByCapability: byCapability,
+    sessionCount: sessions.length,
+    pipelineCount: pipelines.length,
+    recentEventCount: events.length
+  }, null, 2);
+}
+async function buildIssuePrompt(issue, provider, role) {
+  const resolution = resolveTaskCapabilities({
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    description: typeof issue.description === "string" ? issue.description : "",
+    labels: Array.isArray(issue.labels) ? issue.labels.filter((value) => typeof value === "string") : [],
+    paths: Array.isArray(issue.paths) ? issue.paths.filter((value) => typeof value === "string") : []
+  });
+  return renderPrompt("mcp-issue", {
+    role,
+    provider,
+    id: issue.id,
+    title: issue.title,
+    state: issue.state ?? "Todo",
+    capabilityCategory: resolution.category,
+    overlays: resolution.overlays,
+    paths: Array.isArray(issue.paths) ? issue.paths.filter((value) => typeof value === "string") : [],
+    description: issue.description || "No description provided."
+  });
+}
+async function listResourcesMcp() {
+  const issues = await getIssues();
+  const resources = [
+    { uri: "fifony://guide/overview", name: "Fifony overview", description: "High-level overview and local integration guide.", mimeType: "text/markdown" },
+    { uri: "fifony://guide/runtime", name: "Fifony runtime guide", description: "Detailed local runtime reference for the package.", mimeType: "text/markdown" },
+    { uri: "fifony://guide/integration", name: "Fifony MCP integration guide", description: "How to wire an MCP client to this Fifony workspace.", mimeType: "text/markdown" },
+    { uri: "fifony://state/summary", name: "Fifony state summary", description: "Compact summary of the current runtime, issue, and pipeline state.", mimeType: "application/json" },
+    { uri: "fifony://issues", name: "Fifony issues", description: "Full issue list from the durable Fifony store.", mimeType: "application/json" },
+    { uri: "fifony://integrations", name: "Fifony integrations", description: "Discovered local integrations such as agency-agents and impeccable skills.", mimeType: "application/json" },
+    { uri: "fifony://capabilities", name: "Fifony capability routing", description: "How Fifony would route current issues to providers, profiles, and overlays.", mimeType: "application/json" }
+  ];
+  if (existsSync3(WORKFLOW_PATH)) {
+    resources.push({ uri: "fifony://workspace/workflow", name: "Workspace workflow", description: "The active WORKFLOW.md from the target workspace.", mimeType: "text/markdown" });
+  }
+  for (const issue of issues.slice(0, 100)) {
+    resources.push({ uri: `fifony://issue/${encodeURIComponent(issue.id)}`, name: `Issue ${issue.id}`, description: issue.title, mimeType: "application/json" });
+  }
+  return resources;
+}
+async function readResource(uri) {
+  if (uri === "fifony://guide/overview") return [{ uri, mimeType: "text/markdown", text: safeRead(README_PATH) }];
+  if (uri === "fifony://guide/runtime") return [{ uri, mimeType: "text/markdown", text: safeRead(FIFONY_GUIDE_PATH) }];
+  if (uri === "fifony://guide/integration") return [{ uri, mimeType: "text/markdown", text: await buildIntegrationGuide() }];
+  if (uri === "fifony://state/summary") return [{ uri, mimeType: "application/json", text: await buildStateSummary() }];
+  if (uri === "fifony://issues") return [{ uri, mimeType: "application/json", text: JSON.stringify(await getIssues(), null, 2) }];
+  if (uri === "fifony://integrations") {
+    return [{ uri, mimeType: "application/json", text: JSON.stringify(discoverIntegrations(WORKSPACE_ROOT), null, 2) }];
+  }
+  if (uri === "fifony://capabilities") {
+    const issues = await getIssues();
+    return [{
+      uri,
+      mimeType: "application/json",
+      text: JSON.stringify(
+        issues.map((issue) => ({
+          issueId: issue.id,
+          title: issue.title,
+          paths: Array.isArray(issue.paths) ? issue.paths.filter((value) => typeof value === "string") : [],
+          inferredPaths: inferCapabilityPaths({
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title,
+            description: issue.description,
+            labels: Array.isArray(issue.labels) ? issue.labels.filter((value) => typeof value === "string") : [],
+            paths: Array.isArray(issue.paths) ? issue.paths.filter((value) => typeof value === "string") : []
+          }),
+          resolution: resolveTaskCapabilities({
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title,
+            description: issue.description,
+            labels: Array.isArray(issue.labels) ? issue.labels.filter((value) => typeof value === "string") : [],
+            paths: Array.isArray(issue.paths) ? issue.paths.filter((value) => typeof value === "string") : []
+          })
+        })),
+        null,
+        2
+      )
+    }];
+  }
+  if (uri === "fifony://workspace/workflow") return [{ uri, mimeType: "text/markdown", text: safeRead(WORKFLOW_PATH) }];
+  if (uri.startsWith("fifony://issue/")) {
+    const issueId = decodeURIComponent(uri.substring("fifony://issue/".length));
+    const issue = await getIssue(issueId);
+    if (!issue) throw new Error(`Issue not found: ${issueId}`);
+    return [{ uri, mimeType: "application/json", text: JSON.stringify(issue, null, 2) }];
+  }
+  throw new Error(`Unknown resource: ${uri}`);
+}
+function listPrompts() {
+  return [
+    { name: "fifony-integrate-client", description: "Generate setup instructions for connecting an MCP-capable client to Fifony.", arguments: [{ name: "client", description: "Client name, e.g. codex or claude.", required: true }, { name: "goal", description: "What the client should do with Fifony.", required: false }] },
+    { name: "fifony-plan-issue", description: "Generate a planning prompt for a specific issue in the Fifony store.", arguments: [{ name: "issueId", description: "Issue identifier.", required: true }, { name: "provider", description: "Agent provider name.", required: false }] },
+    { name: "fifony-review-workflow", description: "Review the current WORKFLOW.md and propose improvements for orchestration quality.", arguments: [{ name: "provider", description: "Reviewing model or client.", required: false }] },
+    { name: "fifony-use-integration", description: "Generate a concrete integration prompt for agency-agents or impeccable.", arguments: [{ name: "integration", description: "Integration id: agency-agents or impeccable.", required: true }] },
+    { name: "fifony-route-task", description: "Explain which providers, profiles, and overlays Fifony would choose for a task.", arguments: [{ name: "title", description: "Task title.", required: true }, { name: "description", description: "Task description.", required: false }, { name: "labels", description: "Comma-separated labels.", required: false }, { name: "paths", description: "Comma-separated target paths or files.", required: false }] }
+  ];
+}
+async function getPrompt(name, args = {}) {
+  if (name === "fifony-integrate-client") {
+    const client = typeof args.client === "string" && args.client.trim() ? args.client.trim() : "mcp-client";
+    const goal = typeof args.goal === "string" && args.goal.trim() ? args.goal.trim() : "integrate with the local Fifony workspace";
+    const integrationGuide = await buildIntegrationGuide();
+    return {
+      description: "Client integration prompt for Fifony.",
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: await renderPrompt("mcp-integrate-client", { client, goal, integrationGuide })
+        }
+      }]
+    };
+  }
+  if (name === "fifony-plan-issue") {
+    const issueId = typeof args.issueId === "string" ? args.issueId : "";
+    const provider = typeof args.provider === "string" && args.provider.trim() ? args.provider.trim() : "codex";
+    const issue = issueId ? await getIssue(issueId) : null;
+    if (!issue) throw new Error(`Issue not found: ${issueId}`);
+    return {
+      description: "Issue planning prompt grounded in the Fifony issue store.",
+      messages: [{
+        role: "user",
+        content: { type: "text", text: await buildIssuePrompt(issue, provider, "planner") }
+      }]
+    };
+  }
+  if (name === "fifony-review-workflow") {
+    const provider = typeof args.provider === "string" && args.provider.trim() ? args.provider.trim() : "claude";
+    return {
+      description: "Workflow review prompt for Fifony orchestration.",
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: await renderPrompt("mcp-review-workflow", {
+            provider,
+            workspaceRoot: WORKSPACE_ROOT,
+            workflowPresent: existsSync3(WORKFLOW_PATH) ? "yes" : "no"
+          })
+        }
+      }]
+    };
+  }
+  if (name === "fifony-use-integration") {
+    const integration = typeof args.integration === "string" ? args.integration : "";
+    return {
+      description: "Integration guidance for a discovered Fifony extension.",
+      messages: [{
+        role: "user",
+        content: { type: "text", text: await buildIntegrationSnippet(integration, WORKSPACE_ROOT) }
+      }]
+    };
+  }
+  if (name === "fifony-route-task") {
+    const title = typeof args.title === "string" ? args.title : "";
+    const description = typeof args.description === "string" ? args.description : "";
+    const labels = typeof args.labels === "string" ? args.labels.split(",").map((label) => label.trim()).filter(Boolean) : [];
+    const paths = typeof args.paths === "string" ? args.paths.split(",").map((value) => value.trim()).filter(Boolean) : [];
+    const resolution = resolveTaskCapabilities({ title, description, labels, paths });
+    return {
+      description: "Task routing prompt produced by the Fifony capability resolver.",
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: await renderPrompt("mcp-route-task", {
+            resolutionJson: JSON.stringify(resolution, null, 2)
+          })
+        }
+      }]
+    };
+  }
+  throw new Error(`Unknown prompt: ${name}`);
+}
+function listTools() {
+  return [
+    { name: "fifony.status", description: "Return a compact status summary for the current Fifony workspace.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
+    { name: "fifony.list_issues", description: "List issues from the Fifony durable store.", inputSchema: { type: "object", properties: { state: { type: "string" }, capabilityCategory: { type: "string" }, category: { type: "string" } }, additionalProperties: false } },
+    { name: "fifony.create_issue", description: "Create a new issue directly in the Fifony durable store.", inputSchema: { type: "object", properties: { id: { type: "string" }, title: { type: "string" }, description: { type: "string" }, priority: { type: "number" }, state: { type: "string" }, labels: { type: "array", items: { type: "string" } }, paths: { type: "array", items: { type: "string" } } }, required: ["title"], additionalProperties: false } },
+    { name: "fifony.update_issue_state", description: "Update an issue state in the Fifony store and append an event.", inputSchema: { type: "object", properties: { issueId: { type: "string" }, state: { type: "string" }, note: { type: "string" } }, required: ["issueId", "state"], additionalProperties: false } },
+    { name: "fifony.integration_config", description: "Generate a ready-to-paste MCP client configuration snippet for this Fifony workspace.", inputSchema: { type: "object", properties: { client: { type: "string" } }, additionalProperties: false } },
+    { name: "fifony.list_integrations", description: "List discovered local integrations such as agency-agents profiles and impeccable skills.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
+    { name: "fifony.integration_snippet", description: "Generate a workflow or prompt snippet for a discovered integration.", inputSchema: { type: "object", properties: { integration: { type: "string" } }, required: ["integration"], additionalProperties: false } },
+    { name: "fifony.resolve_capabilities", description: "Resolve which providers, roles, profiles, and overlays Fifony should use for a task.", inputSchema: { type: "object", properties: { title: { type: "string" }, description: { type: "string" }, labels: { type: "array", items: { type: "string" } }, paths: { type: "array", items: { type: "string" } } }, required: ["title"], additionalProperties: false } }
+  ];
+}
+function toolText(text) {
+  return { content: [{ type: "text", text }] };
+}
+async function callTool(name, args = {}) {
+  if (name === "fifony.status") return toolText(await buildStateSummary());
+  if (name === "fifony.list_issues") {
+    const stateFilter = typeof args.state === "string" && args.state.trim() ? args.state.trim() : "";
+    const capabilityCategory = typeof args.capabilityCategory === "string" && args.capabilityCategory.trim() ? args.capabilityCategory.trim() : typeof args.category === "string" && args.category.trim() ? args.category.trim() : "";
+    return toolText(JSON.stringify(await listIssues({ state: stateFilter || void 0, capabilityCategory: capabilityCategory || void 0 }), null, 2));
+  }
+  if (name === "fifony.create_issue") {
+    await initDatabase();
+    const { issueResource: issueResource2 } = getResources();
+    const title = typeof args.title === "string" ? args.title.trim() : "";
+    if (!title) throw new Error("title is required");
+    const explicitId = typeof args.id === "string" && args.id.trim() ? args.id.trim() : "";
+    const issueId = explicitId || `LOCAL-${hashInput(`${title}:${nowIso()}`)}`.toUpperCase();
+    const description = typeof args.description === "string" ? args.description : "";
+    const priority = typeof args.priority === "number" ? args.priority : 2;
+    const state = typeof args.state === "string" && args.state.trim() ? args.state.trim() : "Todo";
+    const baseLabels = Array.isArray(args.labels) ? args.labels.filter((value) => typeof value === "string") : ["fifony", "mcp"];
+    const paths = Array.isArray(args.paths) ? args.paths.filter((value) => typeof value === "string") : [];
+    const inferredPaths = inferCapabilityPaths({ id: issueId, identifier: issueId, title, description, labels: baseLabels, paths });
+    const resolution = resolveTaskCapabilities({ id: issueId, identifier: issueId, title, description, labels: baseLabels, paths });
+    const labels = [...new Set([...baseLabels, resolution.category ? `capability:${resolution.category}` : "", ...resolution.overlays.map((overlay) => `overlay:${overlay}`)].filter(Boolean))];
+    const record = await issueResource2?.insert({
+      id: issueId,
+      identifier: issueId,
+      title,
+      description,
+      priority,
+      state,
+      labels,
+      paths,
+      inferredPaths,
+      capabilityCategory: resolution.category,
+      capabilityOverlays: resolution.overlays,
+      capabilityRationale: resolution.rationale,
+      blockedBy: [],
+      assignedToWorker: false,
+      createdAt: nowIso(),
+      url: `fifony://local/${issueId}`,
+      updatedAt: nowIso(),
+      history: [`[${nowIso()}] Issue created via MCP.`],
+      attempts: 0,
+      maxAttempts: 3
+    });
+    await appendEvent("info", `Issue ${issueId} created through MCP.`, { title, state, labels, paths, inferredPaths, capabilityCategory: resolution.category }, issueId);
+    return toolText(JSON.stringify(record ?? { id: issueId }, null, 2));
+  }
+  if (name === "fifony.update_issue_state") {
+    await initDatabase();
+    const { issueResource: issueResource2 } = getResources();
+    const issueId = typeof args.issueId === "string" ? args.issueId.trim() : "";
+    const state = typeof args.state === "string" ? args.state.trim() : "";
+    const note = typeof args.note === "string" ? args.note : "";
+    if (!issueId || !state) throw new Error("issueId and state are required");
+    const current = await issueResource2?.get(issueId);
+    if (!current) throw new Error(`Issue not found: ${issueId}`);
+    const updated = await issueResource2?.update(issueId, { state, updatedAt: nowIso() });
+    await appendEvent("info", note || `Issue ${issueId} moved to ${state} through MCP.`, { state }, issueId);
+    return toolText(JSON.stringify(updated ?? { id: issueId, state }, null, 2));
+  }
+  if (name === "fifony.integration_config") {
+    const client = typeof args.client === "string" && args.client.trim() ? args.client.trim() : "client";
+    return toolText(JSON.stringify({ client, mcpServers: { fifony: { command: "npx", args: ["fifony", "mcp", "--workspace", WORKSPACE_ROOT, "--persistence", PERSISTENCE_ROOT] } } }, null, 2));
+  }
+  if (name === "fifony.list_integrations") return toolText(JSON.stringify(discoverIntegrations(WORKSPACE_ROOT), null, 2));
+  if (name === "fifony.integration_snippet") {
+    const integration = typeof args.integration === "string" ? args.integration : "";
+    return toolText(await buildIntegrationSnippet(integration, WORKSPACE_ROOT));
+  }
+  if (name === "fifony.resolve_capabilities") {
+    const title = typeof args.title === "string" ? args.title : "";
+    const description = typeof args.description === "string" ? args.description : "";
+    const labels = Array.isArray(args.labels) ? args.labels.filter((value) => typeof value === "string") : [];
+    const paths = Array.isArray(args.paths) ? args.paths.filter((value) => typeof value === "string") : [];
+    return toolText(JSON.stringify({ inferredPaths: inferCapabilityPaths({ title, description, labels, paths }), resolution: resolveTaskCapabilities({ title, description, labels, paths }) }, null, 2));
+  }
+  throw new Error(`Unknown tool: ${name}`);
+}
+function sendMessage(message) {
+  const payload = Buffer.from(JSON.stringify(message), "utf8");
+  stdout.write(`Content-Length: ${payload.length}\r
+\r
+`);
+  stdout.write(payload);
+}
+function sendResult(id, result) {
+  sendMessage({ jsonrpc: "2.0", id, result });
+}
+function sendError(id, code, message, data) {
+  sendMessage({ jsonrpc: "2.0", id, error: { code, message, data } });
+}
+async function handleRequest(request) {
+  const id = request.id ?? null;
+  try {
+    switch (request.method) {
+      case "initialize":
+        sendResult(id, { protocolVersion: "2024-11-05", capabilities: { resources: {}, tools: {}, prompts: {} }, serverInfo: { name: "fifony", version: "0.1.0" } });
+        return;
+      case "notifications/initialized":
+        return;
+      case "ping":
+        sendResult(id, {});
+        return;
+      case "resources/list":
+        sendResult(id, { resources: await listResourcesMcp() });
+        return;
+      case "resources/read":
+        sendResult(id, { contents: await readResource(String(request.params?.uri ?? "")) });
+        return;
+      case "tools/list":
+        sendResult(id, { tools: listTools() });
+        return;
+      case "tools/call":
+        sendResult(id, await callTool(String(request.params?.name ?? ""), request.params?.arguments ?? {}));
+        return;
+      case "prompts/list":
+        sendResult(id, { prompts: listPrompts() });
+        return;
+      case "prompts/get":
+        sendResult(id, await getPrompt(String(request.params?.name ?? ""), request.params?.arguments ?? {}));
+        return;
+      default:
+        sendError(id, -32601, `Method not found: ${request.method}`);
+    }
+  } catch (error) {
+    sendError(id, -32e3, String(error));
+  }
+}
+function processIncomingBuffer() {
+  while (true) {
+    const separatorIndex = incomingBuffer.indexOf("\r\n\r\n");
+    if (separatorIndex === -1) return;
+    const headerText = incomingBuffer.subarray(0, separatorIndex).toString("utf8");
+    const contentLengthHeader = headerText.split("\r\n").find((line) => line.toLowerCase().startsWith("content-length:"));
+    if (!contentLengthHeader) {
+      incomingBuffer = Buffer.alloc(0);
+      return;
+    }
+    const contentLength = Number.parseInt(contentLengthHeader.split(":")[1]?.trim() ?? "0", 10);
+    const messageStart = separatorIndex + 4;
+    const messageEnd = messageStart + contentLength;
+    if (incomingBuffer.length < messageEnd) return;
+    const messageBody = incomingBuffer.subarray(messageStart, messageEnd).toString("utf8");
+    incomingBuffer = incomingBuffer.subarray(messageEnd);
+    let request;
+    try {
+      request = JSON.parse(messageBody);
+    } catch (error) {
+      sendError(null, -32700, `Invalid JSON: ${String(error)}`);
+      continue;
+    }
+    void handleRequest(request);
+  }
+}
+async function bootstrap() {
+  debugBoot2("mcp:bootstrap:start");
+  await initDatabase();
+  debugBoot2("mcp:bootstrap:database-ready");
+  await appendEvent("info", "Fifony MCP server started.", { workspaceRoot: WORKSPACE_ROOT, persistenceRoot: PERSISTENCE_ROOT });
+  stdin.on("data", (chunk) => {
+    incomingBuffer = Buffer.concat([incomingBuffer, chunk]);
+    processIncomingBuffer();
+  });
+  stdin.resume();
+  debugBoot2("mcp:bootstrap:stdin-ready");
+}
+bootstrap().catch((error) => {
+  sendError(null, -32001, `Failed to start Fifony MCP server: ${String(error)}`);
+  process.exit(1);
+});
+process.on("SIGINT", async () => {
+  const db = getDatabase();
+  if (db) await db.disconnect();
+  process.exit(0);
+});
+process.on("SIGTERM", async () => {
+  const db = getDatabase();
+  if (db) await db.disconnect();
+  process.exit(0);
+});
+//# sourceMappingURL=server.js.map