@claudetools/tools 0.7.0 → 0.7.2

package/dist/helpers/config.js

@@ -3,6 +3,7 @@
 // =============================================================================
 import { mcpLogger } from '../logger.js';
 import * as fs from 'fs';
+import * as path from 'path';
 import { getConfig, getConfigDir, getProjectsPath, } from './config-manager.js';
 import { getOrRegisterProject } from './project-registration.js';
 // Configuration - now loaded from config manager
@@ -10,6 +11,28 @@ const config = getConfig();
 export const API_BASE_URL = config.apiUrl;
 export const CLAUDETOOLS_DIR = getConfigDir();
 export const PROJECTS_FILE = getProjectsPath();
+const SESSION_CONTEXT_FILE = path.join(CLAUDETOOLS_DIR, 'session-context.md');
+/**
+ * Read project ID from session-context.md (written by session-start hook)
+ * This is the most reliable source since it's set by Claude Code's hook system
+ */
+function getProjectIdFromSessionContext() {
+    try {
+        if (!fs.existsSync(SESSION_CONTEXT_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(SESSION_CONTEXT_FILE, 'utf-8');
+        // Parse: **Project ID:** proj_xxxxx
+        const match = content.match(/\*\*Project ID:\*\*\s*(proj_[a-f0-9]{20})/);
+        if (match) {
+            return match[1];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // Cache for resolved project ID
 let resolvedProjectId = null;
 /**
@@ -93,6 +116,14 @@ export async function resolveProjectIdAsync() {
         mcpLogger.debug('MEMORY', `Using project ID from env: ${resolvedProjectId}`);
         return resolvedProjectId;
     }
+    // Check session-context.md (written by Claude Code's session-start hook)
+    // This is the most reliable source since MCP server's cwd isn't the project dir
+    const sessionProjectId = getProjectIdFromSessionContext();
+    if (sessionProjectId) {
+        resolvedProjectId = sessionProjectId;
+        mcpLogger.info('MEMORY', `Project resolved from session context: ${resolvedProjectId}`);
+        return resolvedProjectId;
+    }
     const cwd = process.cwd();
     // Check projects.json cache
     const binding = findProjectBinding(cwd);
@@ -134,13 +165,19 @@ export async function resolveProjectIdAsync() {
 let _defaultProjectId = null;
 /**
  * Gets the default project ID (synchronous version)
- * Throws if not already resolved - call resolveProjectIdAsync() first
+ * Checks session-context.md first, then config, then falls back to cwd resolution
  */
 export function getDefaultProjectId() {
     if (_defaultProjectId) {
         return _defaultProjectId;
     }
-    // Try config first
+    // Check session-context.md first (most reliable for MCP server)
+    const sessionProjectId = getProjectIdFromSessionContext();
+    if (sessionProjectId) {
+        _defaultProjectId = sessionProjectId;
+        return _defaultProjectId;
+    }
+    // Try config second
     if (config.defaultProjectId) {
         if (!isValidProjectId(config.defaultProjectId)) {
             // Legacy format - convert to local_ format instead of throwing

package/dist/helpers/workers.js

@@ -37,11 +37,17 @@ When complete, provide a concise summary of changes made.`,
 - Response formatting
 - Error handling for endpoints
 
-CODEDNA PRIORITY: Before writing CRUD code manually, check if CodeDNA can generate it:
-- Look for Entity DSL in task (e.g., "User(email:string:unique, password:string:hashed)")
-- Call codedna_generate_api(spec, framework="express", options={...})
-- This generates models, controllers, routes, validation in seconds
-- Only write manually for complex business logic that can't be generated
+PATTERN DETECTION (for existing projects):
+1. Call codedna_detect_patterns(package_json) to find existing patterns
+2. MATCH detected patterns - don't introduce conflicting libraries
+3. Check for: zod vs yup validation, tanstack-query vs swr, etc.
+
+CODEDNA PRIORITY: Before writing CRUD code manually:
+1. Call codedna_list_generators() to discover available generators
+2. Look for Entity DSL in task (e.g., "User(email:string:unique, password:string:hashed)")
+3. Detect framework from project (check package.json, existing patterns)
+4. Call codedna_generate_api(spec, framework="<detected>", options={...})
+5. Only write manually for complex business logic that can't be generated
 
 Focus only on API-related changes. Do not modify schema or extraction code.
 When complete, provide a concise summary of endpoints created or modified.`,
@@ -99,6 +105,40 @@ TOOLS: Use codebase_context to see file dependencies.
 
 Focus on integration without modifying core implementation logic.
 When complete, provide a concise summary of integrations configured.`,
+    },
+    'frontend-expert': {
+        id: 'frontend-expert',
+        name: 'Frontend Expert',
+        description: 'Specialises in React, Vue, and frontend component development',
+        domains: ['**/components/**', '**/pages/**', '**/app/**', '**/*.tsx', '**/*.vue'],
+        capabilities: ['react', 'vue', 'components', 'forms', 'tables', 'styling'],
+        promptTemplate: `You are a frontend development expert. Your domain is limited to:
+- React/Vue components and pages
+- Form and table components
+- UI component libraries
+- Client-side state management
+
+PATTERN DETECTION (CRITICAL for existing projects):
+1. Call codedna_detect_patterns(package_json) to detect existing patterns
+2. RESPECT detected patterns - consistency > "better":
+   - Compound components? Use compound pattern
+   - React Hook Form? Don't introduce Formik
+   - Zustand? Don't add Redux
+   - Tailwind? Match styling approach
+3. Check codedna_list_patterns(category="anti-patterns") for code smells to avoid
+
+CODEDNA PRIORITY: Before writing UI components manually:
+1. Call codedna_list_generators() to discover available generators
+2. Detect UI framework from project (check package.json for react, vue, etc.)
+3. Check for UI library (package.json: @shadcn/ui, @mui/material, @chakra-ui, etc.)
+4. Call codedna_generate_frontend or codedna_generate_component with detected settings
+5. DO NOT assume any specific framework/library - discover via list_generators, detect from project
+
+TOOLS: Use codebase_find to discover existing component patterns.
+TOOLS: Use memory_search for past UI decisions.
+
+Focus on components and pages. Do not modify API or schema code.
+When complete, provide a concise summary of components created.`,
     },
     'general-expert': {
         id: 'general-expert',
@@ -108,7 +148,13 @@ When complete, provide a concise summary of integrations configured.`,
         capabilities: ['general-development', 'refactoring', 'documentation', 'testing'],
         promptTemplate: `You are a general purpose development expert.
 
-CODEDNA: For CRUD/API tasks, use codedna_generate_api before writing code manually.
+CODEDNA - DISCOVER THEN DETECT:
+1. Call codedna_list_generators() to see what's available
+2. Detect project framework from package.json/pyproject.toml
+3. Match detected framework to generator capabilities
+4. If no match, ASK the user which framework to use
+5. DO NOT assume any specific framework exists - always discover first
+
 TOOLS: Use memory_search and codebase_find before implementing from scratch.
 
 Handle this task with care:
@@ -267,7 +313,6 @@ export function matchTaskToWorker(task) {
         'database': 'schema-expert',
         'sql': 'schema-expert',
         'migration': 'schema-expert',
-        'table': 'schema-expert',
         'api': 'api-expert',
         'route': 'api-expert',
         'endpoint': 'api-expert',
@@ -282,6 +327,14 @@ export function matchTaskToWorker(task) {
         'integration': 'integration-expert',
         'config': 'integration-expert',
         'wiring': 'integration-expert',
+        'component': 'frontend-expert',
+        'frontend': 'frontend-expert',
+        'react': 'frontend-expert',
+        'vue': 'frontend-expert',
+        'form': 'frontend-expert',
+        'table': 'frontend-expert',
+        'page': 'frontend-expert',
+        'ui': 'frontend-expert',
     };
     for (const [keyword, workerId] of Object.entries(keywordMap)) {
         if (searchText.includes(keyword)) {

package/dist/templates/orchestrator-prompt.js

@@ -187,15 +187,23 @@ export function buildOrchestratorPrompt(params) {
     - general-expert: Tasks that don't fit other domains`}
   </available_workers>
 
-  <codedna_generators>
-    Workers have access to CodeDNA generators that create production code from Entity DSL:
+  <codedna_generators priority="CRITICAL">
+    CodeDNA generates production code from Entity DSL - workers MUST check availability first.
 
-    - codedna_generate_api: Creates CRUD API (Express, FastAPI, NestJS)
-      → Generates: models, controllers, routes, validation, auth middleware, tests
-      → Token savings: 95-99% vs manual coding
+    BEFORE creating any task involving APIs, CRUD, or UI components:
+    1. Workers should call codedna_list_generators() to see available generators
+    2. If a generator exists, use it instead of writing code manually
 
-    When your tasks involve CRUD operations, define entities using DSL format.
-    Workers will use CodeDNA automatically.
+    AVAILABLE DOMAINS:
+    - api: Express, FastAPI, NestJS (full CRUD with auth, validation, tests)
+    - frontend: React/Next.js, Vue 3 (pages, forms, tables)
+    - component: Forms, tables, cards, modals (React, Vue, Svelte)
+
+    INCLUDE IN TASK DESCRIPTIONS:
+    When tasks involve entities, include the DSL spec so workers know to use CodeDNA:
+    "Create user registration. Entity: User(email:string:unique, password:string:hashed)"
+
+    Token savings: 95-99% vs manual coding
   </codedna_generators>
 
   ${epicTitle ? `<epic_context>

package/dist/templates/worker-prompt.js

@@ -71,16 +71,18 @@ function buildBehavioralSection(taskId) {
     <behavior id="codedna_first" priority="MANDATORY">
       BEFORE writing code manually, check if CodeDNA can generate it:
 
-      FOR CRUD/API operations:
-      → Use codedna_generate_api(spec, framework, options)
+      DISCOVERY WORKFLOW:
+      1. Call codedna_list_generators() to see available generators
+      2. Check if task includes Entity DSL format
+         Example: "User(email:string:unique, password:string:hashed)"
+      3. Detect framework from project (package.json, existing code)
+      4. Match detected framework to generator capabilities
+      5. Call appropriate generator with detected settings
+
+      BENEFITS:
       → Saves 95-99% tokens vs manual coding
       → Generates production-ready code with validation, auth, tests
 
-      FOR Entity definitions:
-      → Check if task includes Entity DSL format
-      → Example: "User(email:string:unique, password:string:hashed)"
-      → Call codedna_generate_api with the spec
-
       ONLY write code manually when:
       - Logic is too complex for generation
       - Modifying existing code (not creating new)
@@ -177,16 +179,12 @@ function buildDomainSection(worker) {
     return `<!-- Layer 4: Domain Knowledge -->
 <domain_knowledge>
   <codedna_capabilities>
-    AVAILABLE GENERATORS:
-
-    1. codedna_generate_api(spec, framework, options)
-       - Frameworks: "express", "fastapi", "nestjs"
-       - Options: { auth: true, validation: true, tests: true }
-       - Generates: model, controller, routes, validation, auth, tests
-
-    2. codedna_validate_spec(spec)
-       - Validates Entity DSL syntax before generation
-       - Returns parsed structure or errors
+    CODEDNA DISCOVERY PATTERN:
+    1. Call codedna_list_generators() to see available generators
+    2. Each generator lists supported frameworks and options
+    3. Detect project framework from package.json/pyproject.toml
+    4. Match detected framework to generator capabilities
+    5. If no match, ASK the user which framework to use
 
     ENTITY DSL FORMAT:
     EntityName(field:type:constraint, field:type:constraint, ...)
@@ -197,20 +195,15 @@ function buildDomainSection(worker) {
     - enum(val1|val2|val3) - enumeration
 
     CONSTRAINTS:
-    - unique - unique constraint
-    - required - not null
-    - min(n), max(n) - numeric bounds
-    - hashed - for passwords (auto bcrypt)
-    - default(value) - default value
-
-    EXAMPLE:
-    codedna_generate_api({
-      spec: "User(email:string:unique:required, password:string:hashed, role:enum(admin|user|guest), created_at:datetime:default(now))",
-      framework: "express",
-      options: { auth: true, validation: true }
-    })
-    → Generates 6 production files in ~5 seconds
-    → Saves ~30,000 tokens vs manual implementation
+    - unique, required, min(n), max(n), hashed, default(value)
+    - UI hints: textarea, switch, radio (for form rendering)
+
+    WORKFLOW:
+    1. codedna_list_generators() → discover capabilities
+    2. codedna_validate_spec(spec) → validate DSL syntax
+    3. codedna_generate_*(spec, framework, options) → generate code
+
+    DO NOT assume frameworks exist - always discover via codedna_list_generators
   </codedna_capabilities>
 
   <worker_expertise>

package/dist/tools.js

@@ -952,6 +952,10 @@ export function registerToolDefinitions(server) {
                                 },
                             },
                         },
+                        package_json: {
+                            type: 'object',
+                            description: 'Optional: package.json content for pattern detection. If provided, generator will detect patterns (zod, yup, etc.) and use matching template variants.',
+                        },
                     },
                     required: ['spec', 'framework'],
                 },
@@ -993,6 +997,10 @@ export function registerToolDefinitions(server) {
                                 },
                             },
                         },
+                        package_json: {
+                            type: 'object',
+                            description: 'Optional: package.json content for pattern detection. Detects React Hook Form, Zod, TanStack Query, etc. and uses matching template variants.',
+                        },
                     },
                     required: ['spec', 'framework'],
                 },
@@ -1031,16 +1039,26 @@ export function registerToolDefinitions(server) {
                                 },
                             },
                         },
+                        package_json: {
+                            type: 'object',
+                            description: 'Optional: package.json content for pattern detection. Detects form libraries, validation tools, etc. and uses matching template variants.',
+                        },
                     },
                     required: ['spec', 'type', 'framework'],
                 },
             },
             {
                 name: 'codedna_list_generators',
-                description: 'List all available code generators and their capabilities.',
+                description: 'CALL THIS BEFORE writing any API, CRUD, or UI component code. Lists available code generators that save 95-99% tokens vs manual coding. Returns generators grouped by domain (api/frontend/component) with their capabilities. If a generator exists for your task, use codedna_generate_* instead of writing code manually.',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        domain: {
+                            type: 'string',
+                            enum: ['api', 'frontend', 'component'],
+                            description: 'Filter by domain: "api" for backend APIs, "frontend" for full frontend apps, "component" for individual UI components',
+                        },
+                    },
                 },
             },
             {
@@ -1057,6 +1075,87 @@ export function registerToolDefinitions(server) {
                     required: ['spec'],
                 },
             },
+            // =========================================================================
+            // CodeDNA Pattern Library Tools
+            // =========================================================================
+            {
+                name: 'codedna_list_patterns',
+                description: 'List coding patterns from the library. Returns best practices (compound components, TanStack Query, Zod) and anti-patterns to avoid (prop drilling, useEffect fetch). Use to understand what patterns are available for a project.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            enum: ['components', 'hooks', 'forms', 'state', 'validation', 'styling', 'anti-patterns'],
+                            description: 'Filter by category',
+                        },
+                        recommended_only: {
+                            type: 'boolean',
+                            description: 'Only return recommended best-practice patterns',
+                        },
+                        include_anti_patterns: {
+                            type: 'boolean',
+                            description: 'Include anti-patterns in results (default: true)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'codedna_get_pattern',
+                description: 'Get detailed documentation for a specific pattern including code examples, when to use/avoid, and migration guides. Use after codedna_list_patterns to get full details.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern_id: {
+                            type: 'string',
+                            description: 'Pattern ID (e.g., "compound-components", "tanstack-query", "prop-drilling")',
+                        },
+                    },
+                    required: ['pattern_id'],
+                },
+            },
+            {
+                name: 'codedna_detect_patterns',
+                description: 'Detect which patterns are used in an existing codebase. Analyzes package.json dependencies and code samples to identify patterns and anti-patterns. Use before making changes to understand project conventions.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        package_json: {
+                            type: 'object',
+                            description: 'The project package.json object (with dependencies/devDependencies)',
+                        },
+                        code_samples: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Code snippets to analyze for pattern signals',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'codedna_init_project',
+                description: 'Initialize a project with recommended patterns. For NEW projects, applies best-practice defaults. For EXISTING projects, use with auto_detect to match existing conventions.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID from claudetools',
+                        },
+                        patterns: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Specific pattern IDs to apply (optional - uses recommended if not specified)',
+                        },
+                        project_type: {
+                            type: 'string',
+                            enum: ['new', 'existing'],
+                            description: '"new" for greenfield (uses recommended), "existing" for updating (detects patterns)',
+                        },
+                    },
+                    required: ['project_id'],
+                },
+            },
         ],
     }));
 }

package/dist/watcher.js

@@ -4,7 +4,9 @@
 // Monitors project directories for changes and syncs with the API
 import { homedir } from 'os';
 import { join } from 'path';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, watch, readdirSync, statSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, watch, readdirSync, statSync, mkdirSync } from 'fs';
+import { getProjectTemplate, SECTION_START } from './templates/claude-md.js';
+import { generateCodebaseMap } from './helpers/codebase-mapper.js';
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
@@ -136,6 +138,94 @@ function discoverProjects(directories) {
     }
     return projects;
 }
+/**
+ * Ensures .claude/CLAUDE.md exists for a project
+ * Creates it if missing, using the project template
+ */
+function ensureProjectClaudeMd(projectPath, projectId, projectName) {
+    const claudeDir = join(projectPath, '.claude');
+    const claudeMdPath = join(claudeDir, 'CLAUDE.md');
+    // Skip if CLAUDE.md already exists with claudetools section
+    if (existsSync(claudeMdPath)) {
+        try {
+            const content = readFileSync(claudeMdPath, 'utf-8');
+            if (content.includes(SECTION_START)) {
+                return false; // Already has claudetools section
+            }
+            // Has CLAUDE.md but no claudetools section - append it
+            const template = getProjectTemplate(projectId, projectName);
+            writeFileSync(claudeMdPath, content.trimEnd() + '\n' + template);
+            log('info', `Added ClaudeTools section to existing CLAUDE.md: ${projectPath}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Create .claude directory if needed
+    if (!existsSync(claudeDir)) {
+        try {
+            mkdirSync(claudeDir, { recursive: true });
+        }
+        catch (err) {
+            log('warn', `Could not create .claude directory for ${projectPath}: ${err}`);
+            return false;
+        }
+    }
+    // Create CLAUDE.md with template
+    try {
+        const template = getProjectTemplate(projectId, projectName);
+        writeFileSync(claudeMdPath, template);
+        log('info', `Created CLAUDE.md for project: ${projectPath}`);
+        return true;
+    }
+    catch (err) {
+        log('warn', `Could not create CLAUDE.md for ${projectPath}: ${err}`);
+        return false;
+    }
+}
+/**
+ * Ensures all synced projects have CLAUDE.md files
+ */
+function ensureAllProjectsHaveClaudeMd(bindings) {
+    let created = 0;
+    for (const binding of bindings) {
+        if (binding.local_path && binding.project_id) {
+            if (ensureProjectClaudeMd(binding.local_path, binding.project_id, binding.project_name || 'Unknown')) {
+                created++;
+            }
+        }
+    }
+    if (created > 0) {
+        log('info', `Created CLAUDE.md for ${created} projects`);
+    }
+}
+/**
+ * Generate codebase maps for all synced projects
+ */
+async function generateMapsForProjects(bindings, apiKey) {
+    let generated = 0;
+    for (const binding of bindings) {
+        if (binding.local_path && binding.project_id) {
+            try {
+                log('info', `Generating codebase map for ${binding.project_name || binding.local_path}...`);
+                const result = await generateCodebaseMap(binding.local_path, binding.project_id, apiKey);
+                if (result.success) {
+                    generated++;
+                }
+                else {
+                    log('warn', `Map generation failed for ${binding.project_name}: ${result.error}`);
+                }
+            }
+            catch (err) {
+                log('warn', `Map generation error for ${binding.project_name}: ${err}`);
+            }
+        }
+    }
+    if (generated > 0) {
+        log('info', `Generated codebase maps for ${generated} projects`);
+    }
+}
 // -----------------------------------------------------------------------------
 // API Sync
 // -----------------------------------------------------------------------------
@@ -166,6 +256,12 @@ async function syncProjectsWithAPI(config, system, projects) {
                 projectsData.bindings = data.bindings;
                 projectsData.last_sync = new Date().toISOString();
                 writeFileSync(PROJECTS_FILE, JSON.stringify(projectsData, null, 2));
+                // Auto-create CLAUDE.md for all synced projects
+                ensureAllProjectsHaveClaudeMd(data.bindings);
+                // Generate codebase maps for all projects (async, don't block)
+                generateMapsForProjects(data.bindings, config.apiKey).catch((err) => {
+                    log('warn', `Map generation failed: ${err}`);
+                });
             }
             log('info', `Synced ${projects.length} projects with API`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -59,7 +59,8 @@
     "chalk": "^5.6.2",
     "nunjucks": "^3.2.4",
     "ora": "^9.0.0",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "typescript": "^5.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",