@magic-ingredients/tiny-brain-local 0.13.0 → 0.14.10

package/dist/tools/plan/plan.tool.js

@@ -1,16 +1,15 @@
 import { z } from 'zod';
 import { createSuccessResult, createErrorResult } from '../index.js';
-import { PlanningService } from '@magic-ingredients/tiny-brain-core';
+import { PlanningService, RepoConfigService, ADRService } from '@magic-ingredients/tiny-brain-core';
 import { toKebabCase } from '@magic-ingredients/tiny-brain-core';
 import { DashboardLauncher } from '../../services/dashboard-launcher.service.js';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { ADRService } from '../../services/adr-service.js';
 const execAsync = promisify(exec);
 const PlanArgsSchema = z.object({
-    operation: z.enum(['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'archive', 'adr', 'create-adr', 'start-dashboard', 'stop-dashboard', 'dashboard-status']),
+    operation: z.enum(['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'archive', 'adr', 'create-adr', 'sync', 'start-dashboard', 'stop-dashboard', 'dashboard-status']),
     // For 'accept' operation
     planName: z.string().optional(),
     planDetails: z.string().optional(),
@@ -140,6 +139,41 @@ async function findUniqueSlug(baseSlug) {
     // Fallback to timestamp-based if we can't find a unique slug
     return `${baseSlug}-${Date.now()}`;
 }
+/**
+ * Count PRD directories in docs/prd/ folder
+ */
+async function countPrdsInRepo(repoRoot) {
+    try {
+        const prdDir = path.join(repoRoot, 'docs', 'prd');
+        const entries = await fs.readdir(prdDir, { withFileTypes: true });
+        return entries.filter(entry => entry.isDirectory()).length;
+    }
+    catch {
+        // If docs/prd doesn't exist or can't be read, return 0
+        return 0;
+    }
+}
+/**
+ * Register repository in the dashboard after accepting a PRD
+ */
+async function registerRepository(context) {
+    try {
+        if (!context.repositoryRoot) {
+            return;
+        }
+        const repoConfigService = new RepoConfigService(context);
+        const repoName = path.basename(context.repositoryRoot);
+        const prdCount = await countPrdsInRepo(context.repositoryRoot);
+        await repoConfigService.registerRepo({
+            name: repoName,
+            path: context.repositoryRoot,
+            prdCount,
+        });
+    }
+    catch {
+        // Don't fail PRD creation if registration fails
+    }
+}
 export class PlanTool {
     static getToolDefinition() {
         return {
@@ -330,12 +364,16 @@ export class PlanTool {
         context.logger?.info?.('[PLAN TOOL] Execute called', { operation: args.operation, cwd: process.cwd() });
         try {
             const validatedArgs = PlanArgsSchema.parse(args);
-            // Validate persona is set for all operations
-            if (!context.activePersona?.id || context.activePersona.id.trim() === '') {
-                return createErrorResult('No active persona found. Plans are persona-specific.\n\n' +
-                    'Use the "as" tool to switch to a persona first:\n' +
-                    '  as <persona-name>\n\n' +
-                    'Or create a new persona if needed.');
+            // Operations that don't require a persona - they're global or repo-scoped only
+            const personaFreeOperations = ['start-dashboard', 'stop-dashboard', 'dashboard-status', 'sync'];
+            // Validate persona is set for persona-specific operations
+            if (!personaFreeOperations.includes(validatedArgs.operation)) {
+                if (!context.activePersona?.id || context.activePersona.id.trim() === '') {
+                    return createErrorResult('No active persona found. Plans are persona-specific.\n\n' +
+                        'Use the "as" tool to switch to a persona first:\n' +
+                        '  as <persona-name>\n\n' +
+                        'Or create a new persona if needed.');
+                }
             }
             // Detect repository root and add to context
             // This ensures git operations work even when MCP server is not in the repo
@@ -368,6 +406,8 @@ export class PlanTool {
                     return await PlanTool.handleAdr(validatedArgs, contextWithRepo);
                 case 'create-adr':
                     return await PlanTool.handleCreateAdr(validatedArgs, contextWithRepo);
+                case 'sync':
+                    return await PlanTool.handleSync(validatedArgs, contextWithRepo);
                 case 'start-dashboard':
                     return await PlanTool.handleStartDashboard(validatedArgs, contextWithRepo);
                 case 'stop-dashboard':
@@ -399,36 +439,48 @@ export class PlanTool {
                 overview: args.planDetails,
                 planDetails: args.planDetails, // Service will extract phases from this
             });
-            // Create PRD markdown in repository
+            // Create PRD files in repository using new helper methods
             // Generate human-readable slug from plan title
             const baseSlug = toKebabCase(plan.title);
             const prdSlug = await findUniqueSlug(baseSlug);
-            const prdPath = `docs/prd/${prdSlug}`;
-            const now = new Date().toISOString();
+            // Attempt PRD creation
+            // Error handling strategy: Verification instead of rollback
+            // - On failure, partial artifacts (empty dirs) are left for retry to reuse
+            // - verifyPRDCreation() ensures we only claim success when files exist
+            // - This approach is simpler and safer than attempting cleanup/rollback
+            let prdCreated = false;
+            let prdErrorMessage = '';
             try {
-                const prdDirPath = await planningService.createPRDMarkdown(prdPath, {
+                // Step 1: Create PRD directory structure (docs/prd/{plan-name}/ and features/)
+                const prdPath = await planningService.createPRDStructure(prdSlug);
+                // Step 2: Write PRD markdown file with YAML frontmatter
+                await planningService.writePRDFile(prdSlug, args.planDetails);
+                // Step 3: Write progress.json file with plan metadata
+                await planningService.writeProgressFile(prdPath, {
                     id: plan.id,
                     title: plan.title,
-                    version: '1.0.0',
-                    status: 'not_started',
-                    created: now,
-                    updated: now,
-                    author: 'Claude Code',
-                }, {
-                    purpose: args.planDetails,
-                    userNeeds: 'To be defined during feature planning',
-                    design: 'To be defined during feature planning',
-                    releaseCriteria: 'To be defined during feature planning',
-                    successMetrics: 'To be defined during feature planning',
-                    constraints: 'To be defined during feature planning',
+                    overview: plan.overview || args.planDetails,
+                    features: plan.features || []
                 });
-                // Update plan with PRD reference
-                plan.prdId = prdSlug;
-                plan.prdDirPath = `${prdPath}/prd.md`;
-                context.logger?.info?.(`Created PRD markdown at ${prdDirPath}`);
+                // Step 4: Verify PRD creation was successful
+                prdCreated = await planningService.verifyPRDCreation(prdSlug);
+                if (prdCreated) {
+                    // Update plan with PRD reference
+                    plan.prdId = prdSlug;
+                    plan.prdDirPath = `${prdPath}/prd.md`;
+                    context.logger?.info?.(`Created PRD files at ${prdPath}`);
+                }
+                else {
+                    // Detailed error: includes full path to help user locate/debug
+                    prdErrorMessage = `PRD verification failed for ${prdPath}/prd.md`;
+                    context.logger?.warn?.(prdErrorMessage);
+                }
             }
             catch (error) {
-                context.logger?.warn?.(`Failed to create PRD markdown: ${error}`);
+                // Detailed error: includes underlying error message and context
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                prdErrorMessage = `Failed to create PRD files: ${errorMsg}`;
+                context.logger?.warn?.(prdErrorMessage);
                 // Continue anyway - the JSON plan was created successfully
             }
             // Set the new plan as active
@@ -440,11 +492,21 @@ export class PlanTool {
             // Format response using service method
             const planStructureJson = await planningService.formatPlanStructure(plan);
             const planStructure = JSON.parse(planStructureJson);
+            // Build response with accurate PRD creation status
+            // Response accuracy: Only show PRD path if verification succeeded
+            // - Success (verified): Show "📋 PRD: {absolute-path}"
+            // - Failure (verified): Show "⚠️ PRD creation failed: {error-details}"
+            // - No attempt: Show empty string
+            const prdStatusLine = prdCreated && plan.prdDirPath
+                ? `📋 PRD: ${plan.prdDirPath}`
+                : prdErrorMessage
+                    ? `⚠️  PRD creation failed: ${prdErrorMessage}`
+                    : '';
             const response = [
                 `✅ Created plan: "${plan.title}"`,
                 `Plan ID: ${plan.id}`,
                 `Persona: ${context.activePersona?.id || 'unknown'}`,
-                plan.prdDirPath ? `📋 PRD: ${plan.prdDirPath}` : '',
+                prdStatusLine,
                 '',
                 `Extracted ${plan.features?.length || 0} features:`,
                 ...(plan.features || []).map((feature, i) => `${i + 1}. ${feature.title}`),
@@ -513,6 +575,8 @@ export class PlanTool {
                 '',
                 'Use "plan operation=status" to see the current status.',
             ].join('\n');
+            // Register repository in dashboard after successful PRD creation
+            await registerRepository(context);
             return createSuccessResult(response);
         }
         catch (error) {
@@ -992,5 +1056,53 @@ export class PlanTool {
             return createErrorResult(`Failed to create ADR: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Handle sync operation - regenerate progress.json from markdown files
+     */
+    static async handleSync(args, context) {
+        try {
+            if (!context.repositoryRoot) {
+                return createErrorResult('Repository root not found. Please run from within a git repository.');
+            }
+            const planningService = new PlanningService(context);
+            // Determine which PRD to sync
+            let prdPath;
+            if (args.planId) {
+                // Sync specific PRD
+                prdPath = path.join(context.repositoryRoot, 'docs', 'prd', args.planId);
+            }
+            else {
+                // Try to sync the active plan
+                const activePlan = await planningService.getActivePlan();
+                if (!activePlan?.prdDirPath) {
+                    return createErrorResult('No active plan found. Specify a planId to sync a specific PRD: plan sync --planId my-prd');
+                }
+                prdPath = path.join(context.repositoryRoot, activePlan.prdDirPath);
+            }
+            // Check if PRD exists
+            const prdMdPath = path.join(prdPath, 'prd.md');
+            try {
+                await fs.access(prdMdPath);
+            }
+            catch {
+                return createErrorResult(`PRD not found at ${prdPath}. Ensure prd.md exists in the specified directory.`);
+            }
+            // Sync the plan from markdown
+            const plan = await planningService.syncPlanFromMarkdown(prdPath);
+            const response = [
+                '✅ Progress synced from markdown!',
+                '',
+                `📋 PRD: ${plan.title}`,
+                `📁 Path: ${plan.prdDirPath}`,
+                `📊 Features: ${plan.features.length}`,
+                `📝 Tasks: ${plan.metadata.totalTasks} (${plan.metadata.completedTasks} completed)`,
+                '',
+                'Progress.json has been updated from the markdown files.',
+            ].join('\n');
+            return createSuccessResult(response);
+        }
+        catch (error) {
+            return createErrorResult(`Failed to sync plan: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
 }
-//# sourceMappingURL=plan.tool.js.map

package/dist/tools/rules/rules.tool.js

@@ -130,4 +130,3 @@ export class RulesTool {
         }
     }
 }
-//# sourceMappingURL=rules.tool.js.map

package/dist/tools/strategy/strategy.tool.js

@@ -196,4 +196,3 @@ export class StrategyTool {
         }
     }
 }
-//# sourceMappingURL=strategy.tool.js.map

package/dist/tools/thinking/thinking.tool.js

@@ -223,4 +223,3 @@ export class ThinkingTool {
         }
     }
 }
-//# sourceMappingURL=thinking.tool.js.map

package/dist/tools/tool-registry.js

@@ -62,4 +62,3 @@ export class ToolRegistry {
 // Export convenience functions
 export const getToolByName = (name) => ToolRegistry.getToolByName(name);
 export const getAllToolNames = () => ToolRegistry.getTools().map((tool) => tool.name);
-//# sourceMappingURL=tool-registry.js.map

package/dist/tools/update/update.tool.js

@@ -83,4 +83,3 @@ export class UpdateTool {
         }
     }
 }
-//# sourceMappingURL=update.tool.js.map

package/dist/tools/validate-response/validate-response.tool.js

@@ -139,4 +139,3 @@ export class ValidateResponseTool {
         }
     }
 }
-//# sourceMappingURL=validate-response.tool.js.map

package/dist/types/local-context.js

@@ -4,4 +4,3 @@
  * Adds local-specific fields to the base RequestContext
  */
 export {};
-//# sourceMappingURL=local-context.js.map

package/dist/types/request-context.d.ts

@@ -3,5 +3,5 @@
  *
  * Re-export the RequestContext from core and extend if needed
  */
-export { RequestContext } from '@magic-ingredients/tiny-brain-core';
+export type { RequestContext } from '@magic-ingredients/tiny-brain-core';
 //# sourceMappingURL=request-context.d.ts.map

package/dist/types/request-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/types/request-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/types/request-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/types/request-context.js

@@ -4,4 +4,3 @@
  * Re-export the RequestContext from core and extend if needed
  */
 export {};
-//# sourceMappingURL=request-context.js.map

package/dist/utils/package-version.js

@@ -23,4 +23,3 @@ export function getPackageVersion() {
         throw new Error(`Failed to read package version: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
-//# sourceMappingURL=package-version.js.map

package/dist/utils/repo-utils.js

@@ -52,4 +52,3 @@ export function getRepoRoot() {
     }
     return cachedRepoRoot;
 }
-//# sourceMappingURL=repo-utils.js.map

package/package.json

@@ -1,14 +1,11 @@
 {
   "name": "@magic-ingredients/tiny-brain-local",
-  "version": "0.13.0",
-  "description": "Local MCP server implementation for Tiny Brain AI assistant",
+  "version": "0.14.10",
+  "description": "MCP server for Tiny Brain AI assistant",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "tiny-brain": "./dist/cli.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -17,46 +14,30 @@
   },
   "files": [
     "dist",
-    "README.md",
-    "templates"
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",
-    "build:server": "tsc",
-    "build:cli": "tsc",
-    "build:all": "npm run build",
     "dev": "tsx src/index.ts",
-    "dev:cli": "tsx src/cli.ts",
-    "dev:server": "tsx src/index.ts",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:cli": "vitest run src/cli",
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build",
-    "dxt:clean": "rm -rf dxt/node_modules dxt/package-lock.json dxt/dist dxt/server/index.js",
-    "dxt:build": "npm run dxt:clean && npm run build && node scripts/bundle-dxt.js",
-    "dxt:pack": "npm run dxt:build && cd dxt && npm install && npx @anthropic-ai/dxt pack . dist/tiny-brain-$(node -p \"require('../package.json').version\").dxt",
-    "dxt:install": "npm install -g @anthropic-ai/dxt",
-    "dxt:init": "cd dxt && dxt init"
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@magic-ingredients/tiny-brain-core": "^0.13.0",
+    "@magic-ingredients/tiny-brain-core": "^0.14.10",
     "@magic-ingredients/tiny-brain-dashboard": "file:../tiny-brain-dashboard",
     "@modelcontextprotocol/sdk": "^1.0.6",
     "chalk": "^5.3.0",
-    "commander": "^12.0.0",
     "dotenv": "^17.2.1",
-    "inquirer": "^9.2.15",
     "marked": "^15.0.0",
     "semver": "^7.7.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@anthropic-ai/dxt": "^0.2.5",
     "@types/node": "^20.14.2",
     "@types/semver": "^7.7.1",
-    "@vercel/blob": "^1.1.1",
     "@vitest/coverage-v8": "^2.1.8",
     "eslint": "^8.57.0",
     "tsx": "^4.19.2",
@@ -71,19 +52,14 @@
     "ai",
     "assistant",
     "tiny-brain",
-    "model-context-protocol",
-    "local-server"
+    "model-context-protocol"
   ],
   "author": "Magic Ingredients",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/magic-ingredients/tiny-brain-local.git",
-    "directory": "packages/tiny-brain-local"
-  },
-  "homepage": "https://github.com/magic-ingredients/tiny-brain-local#readme",
-  "bugs": {
-    "url": "https://github.com/magic-ingredients/tiny-brain-local/issues"
+    "url": "git+https://github.com/magic-ingredients/tiny-brain-local.git",
+    "directory": "packages/tiny-brain-mcp"
   },
   "publishConfig": {
     "access": "public",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Magic Ingredients
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.