@bifocal/mcp 0.1.1 → 0.1.3

package/dist/bifocalClient.js

@@ -17,9 +17,22 @@ async function get(path) {
     }
     return response.json();
 }
+export async function generateSolution(projectId, insightIds, prototypeId, goal, constraints) {
+    const response = await fetch(`${API_URL}/api/projects/${projectId}/solutions/generate`, {
+        method: 'POST',
+        headers: headers(),
+        body: JSON.stringify({ insightIds, prototypeId, goal, constraints }),
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return { solution_id: data.solution_id, status: 'generating' };
+}
 export async function updateProject(projectId, updates) {
-    const response = await fetch(`${API_URL}/api/projects/${projectId}`, {
-        method: 'PATCH',
+    const response = await fetch(`${API_URL}/api/projects/${projectId}/update`, {
+        method: 'POST',
         headers: headers(),
         body: JSON.stringify(updates),
     });
@@ -70,3 +83,39 @@ export async function getPrototype(projectId, prototypeId) {
 export async function exportPrototype(projectId, prototypeId) {
     return get(`/api/projects/${projectId}/prototypes/${prototypeId}/download-zip`);
 }
+export async function importPrototypeUploadUrl(projectId, prototypeName, filename) {
+    const response = await fetch(`${API_URL}/api/projects/${projectId}/prototypes/import/upload-url`, {
+        method: 'POST',
+        headers: headers(),
+        body: JSON.stringify({ prototype_name: prototypeName, filename }),
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+}
+export async function addFeedbackText(projectId, prototypeId, transcript, sessionName) {
+    const response = await fetch(`${API_URL}/api/projects/${projectId}/feedback`, {
+        method: 'POST',
+        headers: headers(),
+        body: JSON.stringify({ prototype_id: prototypeId, transcript, session_name: sessionName }),
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+}
+export async function importPrototypeConfirm(projectId, prototypeId, contextId, filename, s3Key, s3Url) {
+    const response = await fetch(`${API_URL}/api/projects/${projectId}/prototypes/import/confirm`, {
+        method: 'POST',
+        headers: headers(),
+        body: JSON.stringify({ prototype_id: prototypeId, context_id: contextId, filename, s3_key: s3Key, s3_url: s3Url }),
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+}

package/dist/index.js

@@ -2,12 +2,54 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { createProject, updateProject, listProjects, getInsights, getQuotes, getSolutions, getSolution, getPrototypes, getPrototype, exportPrototype } from './bifocalClient.js';
+import { createProject, updateProject, listProjects, importPrototypeUploadUrl, importPrototypeConfirm, addFeedbackText, generateSolution, getInsights, getQuotes, getSolutions, getSolution, getPrototypes, getPrototype, exportPrototype } from './bifocalClient.js';
 import { writeFile } from 'fs/promises';
 import { join } from 'path';
 const server = new Server({ name: 'bifocal', version: '0.1.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
+        {
+            name: 'import_prototype',
+            description: 'Import a local zip file as a prototype into a Bifocal project. Always call get_import_instructions first to ensure the zip is correctly prepared.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_id: { type: 'string', description: 'The ID of the project to import into.' },
+                    prototype_name: { type: 'string', description: 'A name for the prototype.' },
+                    zip_path: { type: 'string', description: 'Absolute path to the zip file on the local filesystem.' },
+                },
+                required: ['project_id', 'prototype_name', 'zip_path'],
+            },
+        },
+        {
+            name: 'add_feedback',
+            description: 'Add feedback to a Bifocal project. Accepts plain text or a path to a PDF file. Text is submitted directly; PDFs are parsed and text extracted before submitting.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_id: { type: 'string', description: 'The ID of the project.' },
+                    prototype_id: { type: 'string', description: 'The ID of the prototype the feedback is about.' },
+                    source: { type: 'string', description: 'The feedback content — either plain text or a local path to a PDF file.' },
+                    session_name: { type: 'string', description: 'Optional name for the feedback session.' },
+                },
+                required: ['project_id', 'prototype_id', 'source'],
+            },
+        },
+        {
+            name: 'get_import_instructions',
+            description: 'Get platform-specific instructions for preparing a prototype zip file before importing it into Bifocal. Always call this before import_prototype.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    platform: {
+                        type: 'string',
+                        enum: ['claudecode', 'lovable', 'figmamake', 'other'],
+                        description: 'The platform the prototype was built with.',
+                    },
+                },
+                required: ['platform'],
+            },
+        },
         {
             name: 'create_project',
             description: 'Create a new Bifocal project. Before calling this tool, always ask the user if they have a PRD or any context to add for the project.',
@@ -61,6 +103,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['project_id', 'insight_id'],
             },
         },
+        {
+            name: 'generate_solution',
+            description: 'Generate a new solution for a project based on selected insights. Before calling this tool, always: (1) call get_insights to show the user the available insights, (2) ask the user which insights they want to prioritize, (3) ask if they have a specific goal or any constraints for the solution. Only call this tool once you have that input. This is async — use get_solutions to check when the solution appears.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_id: { type: 'string', description: 'The ID of the project.' },
+                    insight_ids: { type: 'array', items: { type: 'string' }, description: 'IDs of insights to base the solution on. Use get_insights to find them.' },
+                    prototype_id: { type: 'string', description: 'The ID of the prototype to use as context for the solution.' },
+                    goal: { type: 'string', description: 'Optional goal or focus for the solution.' },
+                    constraints: { type: 'string', description: 'Optional constraints to consider.' },
+                },
+                required: ['project_id', 'insight_ids', 'prototype_id'],
+            },
+        },
         {
             name: 'get_solutions',
             description: 'Get all solutions for a Bifocal project. Returns title, brief, barriers addressed, and prototype link (if one was generated) for each solution.',
@@ -125,6 +182,112 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
+        if (name === 'import_prototype') {
+            const { project_id, prototype_name, zip_path } = args;
+            const filename = zip_path.split('/').pop() || 'prototype.zip';
+            // Step 1: get presigned upload URL
+            const uploadResult = await importPrototypeUploadUrl(project_id, prototype_name, filename);
+            if (uploadResult.warning) {
+                // Surface warning but continue
+                console.warn('[import_prototype]', uploadResult.warning);
+            }
+            // Step 2: read zip and upload to S3
+            const { readFile } = await import('fs/promises');
+            const zipBuffer = await readFile(zip_path);
+            const uploadResponse = await fetch(uploadResult.upload_url, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/zip',
+                    'Content-Encoding': 'identity',
+                },
+                body: zipBuffer,
+            });
+            if (!uploadResponse.ok) {
+                throw new Error(`Failed to upload zip to S3: ${uploadResponse.status}`);
+            }
+            // Step 3: confirm import and queue processing
+            const confirmResult = await importPrototypeConfirm(project_id, uploadResult.prototype_id, uploadResult.context_id, filename, uploadResult.s3_key, uploadResult.s3_url);
+            const response = {
+                prototype_id: confirmResult.prototype_id,
+                status: confirmResult.status,
+                message: 'Prototype uploaded and queued for processing. It will be ready in a few minutes.',
+            };
+            if (uploadResult.warning)
+                response.warning = uploadResult.warning;
+            return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+        }
+        if (name === 'add_feedback') {
+            const { project_id, prototype_id, source, session_name } = args;
+            const ext = source.split('.').pop()?.toLowerCase() || '';
+            const isFilePath = source.startsWith('/') || source.startsWith('./') || source.startsWith('~');
+            if (isFilePath && ext === 'pdf') {
+                // PDF: extract text and submit as transcript
+                const { readFile } = await import('fs/promises');
+                const pdfBuffer = await readFile(source);
+                const pdfParseModule = await import('pdf-parse');
+                const pdfParse = pdfParseModule.default ?? pdfParseModule;
+                const parsed = await pdfParse(pdfBuffer);
+                const result = await addFeedbackText(project_id, prototype_id, parsed.text, session_name);
+                return { content: [{ type: 'text', text: JSON.stringify({ ...result, note: 'Text extracted from PDF.' }, null, 2) }] };
+            }
+            else {
+                // Plain text
+                const result = await addFeedbackText(project_id, prototype_id, source, session_name);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+        }
+        if (name === 'get_import_instructions') {
+            const { platform } = args;
+            const instructions = {
+                claudecode: `⚠️ Do not modify any files in the existing codebase. Read existing files to understand the experience, but never edit them. Create all prototype files in a new separate directory.
+
+Bifocal requires a Vite + React single-page app containing only the experience being tested. Follow these steps:
+
+1. Ask the user: "What specific page or flow do you want to test in Bifocal?" Only include what is needed to render that experience. Remove unrelated pages, routes, and components.
+
+2. Ask: "Is this project built with Next.js or Vite?"
+
+If Next.js:
+- Convert to a Vite + React single-page app with react-router-dom. Remove all SSR, API routes, getServerSideProps, and getStaticProps.
+- Verify: run npm run build and fix any errors before continuing.
+- Create a ZIP excluding node_modules, .git, dist, and any .env files or credentials.
+
+If Vite:
+- Ask: "Does this project use react-router-dom so that each major section has its own URL path?"
+- If no: add react-router-dom with each major section as its own route.
+- Verify: run npm run build and fix any errors before continuing.
+- Create a ZIP excluding node_modules, .git, dist, and any .env files or credentials.
+
+3. Replace any API calls or environment variables with hardcoded fixture data. The prototype must work with no backend and no network requests.
+
+4. Stub out external services — auth, feature flags, analytics, payments, real-time connections — with simple no-op replacements.`,
+                lovable: `To export from Lovable: open your project → top-right menu → Export → Download ZIP.
+
+Do not manually zip the project files — the Export button handles cleanup automatically.`,
+                figmamake: `To export from Figma Make:
+1. In Figma Make, go to Prototype Settings → GitHub and push your project to a GitHub repo.
+2. Go to your GitHub repo → click the green Code button → Download ZIP.
+
+Note: Some Figma assets may not convert correctly after export. If your build fails or images are missing, check that all asset paths are correct.`,
+                other: `⚠️ Do not modify any files in the existing codebase. Read existing files to understand the experience, but never edit them. Create all prototype files in a new separate directory.
+
+Bifocal requires a Vite + React single-page app containing only the experience being tested.
+
+1. Ask the user: "What specific page or flow do you want to test in Bifocal?" Only include what is needed to render that experience. Remove unrelated pages, routes, and components.
+
+2. Your project should have package.json, index.html, and src/ at the root. Next.js is not supported — use Vite. npm run build should output to a dist/ or build/ folder.
+
+3. Replace any API calls or environment variables with hardcoded fixture data. The prototype must work with no backend and no network requests.
+
+4. Stub out external services — auth, feature flags, analytics, payments, real-time connections — with simple no-op replacements.
+
+5. Verify: run npm run build and fix any errors before continuing.
+
+6. Create a ZIP excluding node_modules, .git, dist, and any .env files or credentials.`,
+            };
+            const text = instructions[platform] ?? instructions.other;
+            return { content: [{ type: 'text', text }] };
+        }
         if (name === 'update_project') {
             const { project_id, name: projectName, description } = args;
             const project = await updateProject(project_id, { name: projectName, description });
@@ -158,7 +321,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
             }
             const project = await createProject(projectName, description);
-            return { content: [{ type: 'text', text: JSON.stringify(project, null, 2) }] };
+            const response = {
+                ...project,
+                next_step: "Ask the user if they have a prototype they'd like to import — projects require one to be useful. If yes, call get_import_instructions first to get platform-specific requirements for preparing the zip, then call import_prototype.",
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
         }
         if (name === 'list_projects') {
             const projects = await listProjects();
@@ -174,6 +341,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const quotes = await getQuotes(project_id, insight_id);
             return { content: [{ type: 'text', text: JSON.stringify(quotes, null, 2) }] };
         }
+        if (name === 'generate_solution') {
+            const { project_id, insight_ids, prototype_id, goal, constraints } = args;
+            const result = await generateSolution(project_id, insight_ids, prototype_id, goal, constraints);
+            return { content: [{ type: 'text', text: JSON.stringify({
+                            ...result,
+                            message: 'Solution is being generated. Use get_solutions to check when it appears — typically takes 1-2 minutes.',
+                        }, null, 2) }] };
+        }
         if (name === 'get_solutions') {
             const { project_id } = args;
             const solutions = await getSolutions(project_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifocal/mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Bifocal MCP server — access projects, insights, and prototypes from Claude",
   "type": "module",
   "main": "dist/index.js",
@@ -17,10 +17,13 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@types/pdf-parse": "^1.1.5",
+    "pdf-parse": "^2.4.5"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.3.2"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }