@mycompbox/compbox-mcp 1.9.1 → 1.10.1

package/index.js

@@ -103,6 +103,22 @@ var init_mailbox = __esm({
   }
 });
 
+// ../shared/dist/types/interview.js
+function isInterviewStatus(value) {
+  return INTERVIEW_STATUSES.includes(value);
+}
+var INTERVIEW_STATUSES;
+var init_interview = __esm({
+  "../shared/dist/types/interview.js"() {
+    "use strict";
+    INTERVIEW_STATUSES = [
+      "in_progress",
+      "completed",
+      "archived"
+    ];
+  }
+});
+
 // ../shared/dist/types/index.js
 var init_types = __esm({
   "../shared/dist/types/index.js"() {
@@ -112,6 +128,7 @@ var init_types = __esm({
     init_invitation();
     init_session_events();
     init_mailbox();
+    init_interview();
   }
 });
 
@@ -363,11 +380,184 @@ var init_pxpipe = __esm({
   }
 });
 
+// ../shared/dist/interview-definition.js
+function interviewSectionKeys() {
+  return INTERVIEW_DEFINITION.map((s) => s.key);
+}
+function interviewFieldKeys() {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const section of INTERVIEW_DEFINITION) {
+    for (const f of section.fields) {
+      if (!seen.has(f)) {
+        seen.add(f);
+        out.push(f);
+      }
+    }
+  }
+  return out;
+}
+function buildInterviewSystemPrompt(definition = INTERVIEW_DEFINITION) {
+  const requiredSections = definition.filter((s) => s.required);
+  const optionalSections = definition.filter((s) => !s.required);
+  const renderSection = (s) => {
+    const tag = s.required ? "REQUIRED" : "OPTIONAL \u2014 ask, but the user may decline";
+    const followUps = s.followUps.map((q) => `    - ${q}`).join("\n");
+    return `- ${s.title} (${tag}) [json keys: ${s.fields.join(", ")}]
+  ${s.purpose}
+${followUps}`;
+  };
+  const completionKeys = [
+    "title",
+    ...interviewFieldKeysFor(definition),
+    "description"
+  ];
+  const completionShape = completionKeys.map((k) => `"${k}": "..."`).join(", ");
+  return `You are the CompBox request-formulator, interviewing an employee to turn their idea into a well-formed Epic Request. Ask exactly ONE short, focused question at a time \u2014 never multiple questions in one message, never preamble or explanation.
+
+Work through these interview sections in order. Cover EVERY required section; for optional sections, ask about them too, but if the employee has nothing to add or declines, move on and leave that field out (never invent or pad it):
+
+REQUIRED sections (an Epic Request cannot omit these):
+${requiredSections.map(renderSection).join("\n")}
+
+OPTIONAL-BUT-RECOMMENDED sections (ask about each; omit the field if the employee has nothing):
+${optionalSections.map(renderSection).join("\n")}
+
+The employee's answers may be short or casual \u2014 that's fine, but when you write the final fields below, EXPAND them into complete, well-written prose using everything they told you across the whole conversation, not just a compressed one-liner. Each required field is scored by an automated quality rubric with hard minimums, so undershooting length is a real failure, not just a style nitpick:
+- problemStatement: at least ${String(INTERVIEW_FIELD_MIN_WORDS.problemStatement)} words.
+- proposedSolution: at least ${String(INTERVIEW_FIELD_MIN_WORDS.proposedSolution)} words.
+- impactAssessment: at least ${String(INTERVIEW_FIELD_MIN_WORDS.impactAssessment)} words.
+- description: at least ${String(INTERVIEW_FIELD_MIN_WORDS.description)} words. This is a SEPARATE plain-text field (not shown to the employee) that stands alone as a full narrative summary of the whole request \u2014 restate the problem, the proposed solution, and the expected impact in flowing prose, as if writing the request from scratch for someone who hasn't seen the conversation.
+
+Once you have gathered the required sections (and covered the optional ones), respond with ONLY a fenced JSON code block (no other text) in exactly this shape. Include a key for every optional field you gathered; omit any optional field the employee had nothing for:
+\`\`\`json
+{"done": true, ${completionShape}}
+\`\`\`
+
+Until then, respond with ONLY your next question as plain text \u2014 no JSON, no labels, no numbering.`;
+}
+function interviewFieldKeysFor(definition) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const section of definition) {
+    for (const f of section.fields) {
+      if (!seen.has(f)) {
+        seen.add(f);
+        out.push(f);
+      }
+    }
+  }
+  return out;
+}
+var INTERVIEW_DEFINITION, INTERVIEW_FIELD_MIN_WORDS;
+var init_interview_definition = __esm({
+  "../shared/dist/interview-definition.js"() {
+    "use strict";
+    INTERVIEW_DEFINITION = [
+      {
+        key: "problemStatement",
+        title: "Problem Statement",
+        purpose: "Establish the problem or opportunity being addressed, the gap in the current system, who feels it, and the cost of leaving it unsolved.",
+        required: true,
+        followUps: [
+          "What problem are you trying to solve?",
+          "What gap exists in the current system?",
+          "Who is experiencing this problem?",
+          "What's the impact if we don't address it?"
+        ],
+        fields: ["problemStatement"]
+      },
+      {
+        key: "proposedSolution",
+        title: "Proposed Solution",
+        purpose: "Capture what they propose building, how it solves the problem, the high-level approach, and the specific capabilities needed.",
+        required: true,
+        followUps: [
+          "What do you propose building?",
+          "How would this solve the problem?",
+          "What's the high-level approach?",
+          "Are there specific features or capabilities needed?"
+        ],
+        fields: ["proposedSolution"]
+      },
+      {
+        key: "impactAssessment",
+        title: "Impact Assessment",
+        purpose: "Capture who benefits, the expected benefits, how it improves the system/product/workflow, and what outcomes would indicate success.",
+        required: true,
+        followUps: [
+          "Who will benefit from this?",
+          "What are the expected benefits?",
+          "How will this improve the system, product, or workflow?",
+          "What outcomes would indicate success?"
+        ],
+        fields: ["impactAssessment"]
+      },
+      {
+        key: "successMetrics",
+        title: "Success Metrics",
+        purpose: "Define how success is measured \u2014 specific metrics, signals it is working, and the definition of done for the epic.",
+        required: false,
+        followUps: [
+          "What specific metrics would you track?",
+          "How would we know this is working?",
+          `What's the definition of "done" for this epic?`
+        ],
+        fields: ["successMetrics"]
+      },
+      {
+        key: "targetAudience",
+        title: "Target Audience",
+        purpose: "Identify which users or teams benefit, any specific personas or use cases, and whether they are internal or external.",
+        required: false,
+        followUps: [
+          "Which users or teams will use this?",
+          "Are there specific personas or use cases?",
+          "Are these internal or external users?"
+        ],
+        fields: ["targetAudience"]
+      },
+      {
+        key: "technicalContext",
+        title: "Technical Context",
+        purpose: "Surface dependencies and prerequisites, a rough effort estimate, and any technical constraints or risks.",
+        required: false,
+        followUps: [
+          "Are there dependencies or prerequisites?",
+          `What's your rough estimate of effort (e.g., "2-3 weeks", "1 quarter")?`,
+          "Are there technical constraints or risks to be aware of?"
+        ],
+        fields: ["dependencies", "estimatedEffort"]
+      },
+      {
+        key: "alternatives",
+        title: "Alternatives Considered",
+        purpose: "Capture alternative approaches that were considered and why they were not chosen.",
+        required: false,
+        followUps: [
+          "Are there alternative approaches you considered?",
+          "Why were those alternatives not chosen?"
+        ],
+        fields: ["alternatives"]
+      }
+    ];
+    INTERVIEW_FIELD_MIN_WORDS = {
+      problemStatement: 60,
+      proposedSolution: 100,
+      impactAssessment: 40,
+      description: 150
+    };
+  }
+});
+
 // ../shared/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   APPEND_DESCRIPTION_MAX: () => APPEND_DESCRIPTION_MAX,
   DESCRIPTION_MAX: () => DESCRIPTION_MAX,
+  INTERVIEW_DEFINITION: () => INTERVIEW_DEFINITION,
+  INTERVIEW_FIELD_MIN_WORDS: () => INTERVIEW_FIELD_MIN_WORDS,
+  INTERVIEW_STATUSES: () => INTERVIEW_STATUSES,
   JOB_STATUSES: () => JOB_STATUSES,
   JOB_TYPES: () => JOB_TYPES,
   MACHINE_STATUSES: () => MACHINE_STATUSES,
@@ -377,12 +567,16 @@ __export(dist_exports, {
   SessionEventType: () => SessionEventType,
   TURN_ROLES: () => TURN_ROLES,
   agentSchema: () => agentSchema,
+  buildInterviewSystemPrompt: () => buildInterviewSystemPrompt,
   err: () => err,
   getAnthropicProxyUrl: () => getAnthropicProxyUrl,
   getModelById: () => getModelById,
   getModelDisplayName: () => getModelDisplayName,
   getOpenAiProxyUrl: () => getOpenAiProxyUrl,
   instructionSchema: () => instructionSchema,
+  interviewFieldKeys: () => interviewFieldKeys,
+  interviewSectionKeys: () => interviewSectionKeys,
+  isInterviewStatus: () => isInterviewStatus,
   isJobStatus: () => isJobStatus,
   isJobType: () => isJobType,
   isMachineStatus: () => isMachineStatus,
@@ -417,6 +611,7 @@ var init_dist = __esm({
     init_skill_packs();
     init_model_catalog();
     init_pxpipe();
+    init_interview_definition();
   }
 });
 
@@ -10445,26 +10640,6 @@ function registerSkillPackTools(server2) {
 }
 
 // src/tools/index.ts
-var CANONICAL_TOOL_PREFIX = "compbox__";
-var LEGACY_ALIAS_PREFIX = "spectree__";
-function withLegacyAliases(server2) {
-  return new Proxy(server2, {
-    get(target, prop, receiver) {
-      if (prop === "registerTool") {
-        return (name, config, handler) => {
-          const registered = target.registerTool(name, config, handler);
-          if (name.startsWith(CANONICAL_TOOL_PREFIX)) {
-            const legacyName = LEGACY_ALIAS_PREFIX + name.slice(CANONICAL_TOOL_PREFIX.length);
-            target.registerTool(legacyName, config, handler);
-          }
-          return registered;
-        };
-      }
-      const value = Reflect.get(target, prop, receiver);
-      return typeof value === "function" ? value.bind(target) : value;
-    }
-  });
-}
 var toolRegistrars = [
   registerHelpTools,
   // Help and documentation tools
@@ -10522,17 +10697,53 @@ var toolRegistrars = [
   // Skill pack management
 ];
 function registerAllTools(server2) {
-  const aliasedServer = withLegacyAliases(server2);
   for (const registrar of toolRegistrars) {
-    registrar(aliasedServer);
+    registrar(server2);
   }
 }
 
+// src/legacy-aliases.ts
+var CANONICAL_TOOL_PREFIX = "compbox__";
+var LEGACY_ALIAS_PREFIX = "spectree__";
+function rewriteLegacyToolCall(message) {
+  if ("method" in message && message.method === "tools/call" && "params" in message && message.params !== null && typeof message.params === "object") {
+    const params = message.params;
+    const name = params.name;
+    if (typeof name === "string" && name.startsWith(LEGACY_ALIAS_PREFIX)) {
+      return {
+        ...message,
+        params: {
+          ...params,
+          name: CANONICAL_TOOL_PREFIX + name.slice(LEGACY_ALIAS_PREFIX.length)
+        }
+      };
+    }
+  }
+  return message;
+}
+function withLegacyToolCallRewrite(transport) {
+  return new Proxy(transport, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    set(target, prop, value, receiver) {
+      if (prop === "onmessage" && typeof value === "function") {
+        const handler = value;
+        const wrapped = (message, extra) => handler(rewriteLegacyToolCall(message), extra);
+        target.onmessage = wrapped;
+        return true;
+      }
+      return Reflect.set(target, prop, value, receiver);
+    }
+  });
+}
+
 // src/index.ts
 var SERVER_NAME = "compbox-mcp";
 function resolveServerVersion() {
   if (true) {
-    return "1.9.1";
+    return "1.10.1";
   }
   const require2 = createRequire(import.meta.url);
   for (const candidate of ["../package.json", "./package.json"]) {
@@ -10583,7 +10794,7 @@ registerAllTools(server);
 async function main() {
   const { token, baseUrl } = validateEnvironment();
   initializeApiClient({ token, baseUrl });
-  const transport = new StdioServerTransport();
+  const transport = withLegacyToolCallRewrite(new StdioServerTransport());
   await server.connect(transport);
   console.error(`${SERVER_NAME} v${SERVER_VERSION} started (stdio transport)`);
   console.error(`API endpoint: ${baseUrl}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycompbox/compbox-mcp",
-  "version": "1.9.1",
+  "version": "1.10.1",
   "description": "CompBox MCP server - Uses HTTP API client (no direct database access)",
   "license": "MIT",
   "type": "module",