anchi-toolkit 1.0.0

package/src/lib/detector.js

@@ -0,0 +1,140 @@
+// =============================================================================
+// Tech Stack Detector
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+function detectTechStack(targetPath) {
+    const detected = {
+        frameworks: [],
+        languages: [],
+        databases: [],
+        styling: [],
+        auth: [],
+        testing: [],
+    };
+
+    // Check package.json
+    const pkgPath = path.join(targetPath, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+            // Frameworks
+            if (deps['next']) detected.frameworks.push('next');
+            if (deps['react']) detected.frameworks.push('react');
+            if (deps['vue']) detected.frameworks.push('vue');
+            if (deps['express']) detected.frameworks.push('express');
+            if (deps['fastify']) detected.frameworks.push('fastify');
+            if (deps['@nestjs/core']) detected.frameworks.push('nestjs');
+
+            // Databases
+            if (deps['prisma'] || deps['@prisma/client']) detected.databases.push('prisma');
+            if (deps['mongoose']) detected.databases.push('mongodb');
+            if (deps['pg']) detected.databases.push('postgresql');
+            if (deps['mysql2']) detected.databases.push('mysql');
+            if (deps['better-sqlite3']) detected.databases.push('sqlite');
+
+            // Styling
+            if (deps['tailwindcss']) detected.styling.push('tailwind');
+            if (deps['styled-components']) detected.styling.push('styled-components');
+            if (deps['@emotion/react']) detected.styling.push('emotion');
+            if (deps['sass']) detected.styling.push('sass');
+
+            // Auth
+            if (deps['next-auth']) detected.auth.push('next-auth');
+            if (deps['better-auth']) detected.auth.push('better-auth');
+            if (deps['passport']) detected.auth.push('passport');
+
+            // Testing
+            if (deps['jest']) detected.testing.push('jest');
+            if (deps['vitest']) detected.testing.push('vitest');
+            if (deps['playwright']) detected.testing.push('playwright');
+
+            // Languages
+            if (deps['typescript']) detected.languages.push('typescript');
+        } catch (e) {
+            // Ignore parse errors
+        }
+    }
+
+    // Check for config files
+    if (fs.existsSync(path.join(targetPath, 'tailwind.config.js')) ||
+        fs.existsSync(path.join(targetPath, 'tailwind.config.ts'))) {
+        if (!detected.styling.includes('tailwind')) detected.styling.push('tailwind');
+    }
+
+    if (fs.existsSync(path.join(targetPath, 'prisma'))) {
+        if (!detected.databases.includes('prisma')) detected.databases.push('prisma');
+    }
+
+    if (fs.existsSync(path.join(targetPath, 'tsconfig.json'))) {
+        if (!detected.languages.includes('typescript')) detected.languages.push('typescript');
+    }
+
+    return detected;
+}
+
+function suggestSkills(detected) {
+    const suggestions = new Set();
+
+    // Framework-based suggestions
+    if (detected.frameworks.includes('next') || detected.frameworks.includes('react')) {
+        suggestions.add('frontend-development');
+        suggestions.add('web-frameworks');
+    }
+    if (detected.frameworks.includes('express') || detected.frameworks.includes('fastify')) {
+        suggestions.add('backend-development');
+    }
+
+    // Database suggestions
+    if (detected.databases.length > 0) {
+        suggestions.add('databases');
+    }
+
+    // Styling suggestions
+    if (detected.styling.includes('tailwind')) {
+        suggestions.add('ui-styling');
+        suggestions.add('frontend-design');
+    }
+
+    // Auth suggestions
+    if (detected.auth.includes('better-auth')) {
+        suggestions.add('better-auth');
+    }
+
+    // Default suggestions if nothing detected
+    if (suggestions.size === 0) {
+        suggestions.add('frontend-development');
+        suggestions.add('planning');
+    }
+
+    return Array.from(suggestions);
+}
+
+function formatDetectedStack(detected) {
+    const parts = [];
+
+    if (detected.frameworks.length) {
+        parts.push(`Frameworks: ${detected.frameworks.join(', ')}`);
+    }
+    if (detected.databases.length) {
+        parts.push(`Database: ${detected.databases.join(', ')}`);
+    }
+    if (detected.styling.length) {
+        parts.push(`Styling: ${detected.styling.join(', ')}`);
+    }
+    if (detected.auth.length) {
+        parts.push(`Auth: ${detected.auth.join(', ')}`);
+    }
+
+    return parts.length > 0 ? parts.join(' | ') : 'No specific tech detected';
+}
+
+module.exports = {
+    detectTechStack,
+    suggestSkills,
+    formatDetectedStack,
+};

package/src/lib/memoryManager.js

@@ -0,0 +1,250 @@
+// =============================================================================
+// anchi-toolkit Memory Manager
+// Saves and loads project context to avoid AI "forgetting"
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+const MEMORY_DIR = '.cursor/context';
+const MEMORY_FILE = 'memory.json';
+
+// Default memory structure
+const DEFAULT_MEMORY = {
+    version: '1.0',
+    project: {
+        name: null,
+        description: null,
+        tech_stack: [],
+        architecture: null,
+        created_at: null,
+        updated_at: null,
+    },
+    session: {
+        last_task: null,
+        current_phase: null,
+        open_files: [],
+        pending_actions: [],
+        last_accessed: null,
+    },
+    decisions: [],
+    notes: [],
+    entities: {},
+};
+
+/**
+ * Get memory file path
+ */
+function getMemoryPath(targetDir) {
+    return path.join(targetDir, MEMORY_DIR, MEMORY_FILE);
+}
+
+/**
+ * Ensure memory directory exists
+ */
+function ensureMemoryDir(targetDir) {
+    const memoryDir = path.join(targetDir, MEMORY_DIR);
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    return memoryDir;
+}
+
+/**
+ * Load memory from file
+ */
+function loadMemory(targetDir = process.cwd()) {
+    const memoryPath = getMemoryPath(targetDir);
+
+    if (!fs.existsSync(memoryPath)) {
+        return { ...DEFAULT_MEMORY };
+    }
+
+    try {
+        const content = fs.readFileSync(memoryPath, 'utf-8');
+        const memory = JSON.parse(content);
+        return { ...DEFAULT_MEMORY, ...memory };
+    } catch (e) {
+        console.warn(`Warning: Could not parse memory: ${e.message}`);
+        return { ...DEFAULT_MEMORY };
+    }
+}
+
+/**
+ * Save memory to file
+ */
+function saveMemory(targetDir, memory) {
+    ensureMemoryDir(targetDir);
+    const memoryPath = getMemoryPath(targetDir);
+
+    memory.session.last_accessed = new Date().toISOString();
+    memory.project.updated_at = new Date().toISOString();
+
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+    return memoryPath;
+}
+
+/**
+ * Update project info
+ */
+function updateProject(targetDir, projectInfo) {
+    const memory = loadMemory(targetDir);
+    memory.project = {
+        ...memory.project,
+        ...projectInfo,
+        updated_at: new Date().toISOString(),
+    };
+    if (!memory.project.created_at) {
+        memory.project.created_at = new Date().toISOString();
+    }
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Update session info
+ */
+function updateSession(targetDir, sessionInfo) {
+    const memory = loadMemory(targetDir);
+    memory.session = {
+        ...memory.session,
+        ...sessionInfo,
+        last_accessed: new Date().toISOString(),
+    };
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add a decision
+ */
+function addDecision(targetDir, decision, reason, filesAffected = []) {
+    const memory = loadMemory(targetDir);
+    memory.decisions.push({
+        id: Date.now(),
+        decision,
+        reason,
+        files_affected: filesAffected,
+        timestamp: new Date().toISOString(),
+    });
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add a note
+ */
+function addNote(targetDir, note, category = 'general') {
+    const memory = loadMemory(targetDir);
+    memory.notes.push({
+        id: Date.now(),
+        note,
+        category,
+        timestamp: new Date().toISOString(),
+    });
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add/update an entity
+ */
+function upsertEntity(targetDir, entityName, entityData) {
+    const memory = loadMemory(targetDir);
+    memory.entities[entityName] = {
+        ...memory.entities[entityName],
+        ...entityData,
+        updated_at: new Date().toISOString(),
+    };
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Get entity
+ */
+function getEntity(targetDir, entityName) {
+    const memory = loadMemory(targetDir);
+    return memory.entities[entityName] || null;
+}
+
+/**
+ * Clear memory
+ */
+function clearMemory(targetDir) {
+    const memory = { ...DEFAULT_MEMORY };
+    memory.project.created_at = new Date().toISOString();
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Get memory summary (for AI context)
+ */
+function getMemorySummary(targetDir) {
+    const memory = loadMemory(targetDir);
+
+    let summary = '';
+
+    // Project info
+    if (memory.project.name) {
+        summary += `## Project: ${memory.project.name}\n`;
+        if (memory.project.description) {
+            summary += `${memory.project.description}\n`;
+        }
+        if (memory.project.tech_stack.length > 0) {
+            summary += `Tech Stack: ${memory.project.tech_stack.join(', ')}\n`;
+        }
+        if (memory.project.architecture) {
+            summary += `Architecture: ${memory.project.architecture}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Session info
+    if (memory.session.last_task) {
+        summary += `## Last Session\n`;
+        summary += `Task: ${memory.session.last_task}\n`;
+        if (memory.session.current_phase) {
+            summary += `Phase: ${memory.session.current_phase}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Recent decisions
+    if (memory.decisions.length > 0) {
+        summary += `## Recent Decisions\n`;
+        const recent = memory.decisions.slice(-5);
+        for (const d of recent) {
+            summary += `- ${d.decision}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Recent notes
+    if (memory.notes.length > 0) {
+        summary += `## Notes\n`;
+        const recent = memory.notes.slice(-5);
+        for (const n of recent) {
+            summary += `- [${n.category}] ${n.note}\n`;
+        }
+    }
+
+    return summary || 'No memory saved yet.';
+}
+
+module.exports = {
+    DEFAULT_MEMORY,
+    loadMemory,
+    saveMemory,
+    updateProject,
+    updateSession,
+    addDecision,
+    addNote,
+    upsertEntity,
+    getEntity,
+    clearMemory,
+    getMemorySummary,
+    getMemoryPath,
+    ensureMemoryDir,
+};

package/src/lib/profiles.js

@@ -0,0 +1,100 @@
+// =============================================================================
+// Role-based Profiles
+// =============================================================================
+
+const PROFILES = {
+    minimal: {
+        name: 'Minimal',
+        description: 'Core commands only (fastest install)',
+        commands: ['start', 'plan', 'cook', 'fix'],
+        agents: [],
+        skills: [],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    developer: {
+        name: 'Developer',
+        description: 'Daily coding (commands + basic agents)',
+        commands: ['start', 'plan', 'cook', 'fix', 'scout', 'generate'],
+        agents: ['planner', 'scout', 'fullstack-developer', 'debugger'],
+        skills: ['frontend-development', 'backend-development', 'databases'],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    ui_ux: {
+        name: 'UI/UX Designer',
+        description: 'Frontend & Design focus',
+        commands: ['start', 'plan', 'cook', 'design-ui', 'generate'],
+        agents: ['ui-ux-designer', 'design-system-architect', 'planner'],
+        skills: ['frontend-development', 'frontend-design', 'ui-styling', 'aesthetic'],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    architect: {
+        name: 'Architect',
+        description: 'System design & DDD',
+        commands: ['start', 'plan', 'cook', 'fix', 'design-domain', 'review'],
+        agents: ['planner', 'ddd-architect', 'code-reviewer', 'researcher'],
+        skills: ['ddd-modular-monolith', 'planning', 'backend-development', 'databases'],
+        includePresets: true,
+        includeDocs: true,
+    },
+
+    lead: {
+        name: 'Team Lead',
+        description: 'Code review & management',
+        commands: ['start', 'plan', 'cook', 'fix', 'review', 'scout', 'summary'],
+        agents: ['planner', 'code-reviewer', 'project-manager', 'docs-manager', 'git-manager'],
+        skills: ['code-review', 'planning', 'debugging'],
+        includePresets: false,
+        includeDocs: true,
+    },
+
+    fullstack: {
+        name: 'Full Stack',
+        description: 'Everything included',
+        commands: 'all',
+        agents: 'all',
+        skills: 'all',
+        includePresets: true,
+        includeDocs: true,
+    },
+};
+
+function getProfile(name) {
+    return PROFILES[name] || null;
+}
+
+function getProfileList() {
+    return Object.entries(PROFILES).map(([key, profile]) => ({
+        key,
+        name: profile.name,
+        description: profile.description,
+    }));
+}
+
+function getProfileEstimate(profileKey) {
+    const profile = PROFILES[profileKey];
+    if (!profile) return null;
+
+    const estimates = {
+        minimal: { files: 5, size: '~50KB' },
+        developer: { files: 30, size: '~300KB' },
+        ui_ux: { files: 25, size: '~250KB' },
+        architect: { files: 50, size: '~500KB' },
+        lead: { files: 40, size: '~400KB' },
+        fullstack: { files: 400, size: '~5MB' },
+    };
+
+    return estimates[profileKey] || { files: '?', size: '?' };
+}
+
+module.exports = {
+    PROFILES,
+    getProfile,
+    getProfileList,
+    getProfileEstimate,
+};

package/src/lib/sizeCalculator.js

@@ -0,0 +1,121 @@
+// =============================================================================
+// Size Calculator
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+function countFilesRecursive(dir) {
+    let count = 0;
+    let size = 0;
+
+    if (!fs.existsSync(dir)) return { count: 0, size: 0 };
+
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const sub = countFilesRecursive(fullPath);
+                count += sub.count;
+                size += sub.size;
+            } else {
+                count++;
+                try {
+                    const stats = fs.statSync(fullPath);
+                    size += stats.size;
+                } catch (e) {
+                    // Ignore
+                }
+            }
+        }
+    } catch (e) {
+        // Ignore
+    }
+
+    return { count, size };
+}
+
+function formatSize(bytes) {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function calculateInstallSize(kitPath, components) {
+    let totalFiles = 0;
+    let totalSize = 0;
+
+    for (const comp of components) {
+        const compPath = path.join(kitPath, comp);
+        if (fs.existsSync(compPath)) {
+            const stats = fs.statSync(compPath);
+            if (stats.isDirectory()) {
+                const { count, size } = countFilesRecursive(compPath);
+                totalFiles += count;
+                totalSize += size;
+            } else {
+                totalFiles++;
+                totalSize += stats.size;
+            }
+        }
+    }
+
+    return {
+        files: totalFiles,
+        size: totalSize,
+        formatted: formatSize(totalSize),
+    };
+}
+
+function getComponentPaths(profile, kitPath) {
+    const components = [];
+
+    // Commands
+    if (profile.commands === 'all') {
+        components.push('.cursor/commands');
+    } else if (Array.isArray(profile.commands)) {
+        profile.commands.forEach(cmd => {
+            components.push(`.cursor/commands/${cmd}.md`);
+        });
+    }
+
+    // Agents
+    if (profile.agents === 'all') {
+        components.push('.cursor/agents');
+    } else if (Array.isArray(profile.agents)) {
+        profile.agents.forEach(agent => {
+            components.push(`.cursor/agents/${agent}.md`);
+        });
+    }
+
+    // Skills
+    if (profile.skills === 'all') {
+        components.push('.cursor/skills');
+    } else if (Array.isArray(profile.skills)) {
+        profile.skills.forEach(skill => {
+            components.push(`.cursor/skills/${skill}`);
+        });
+    }
+
+    // Extras
+    if (profile.includePresets) {
+        components.push('presets');
+    }
+    if (profile.includeDocs) {
+        components.push('docs');
+    }
+
+    // Always include
+    components.push('.cursorrules');
+    components.push('CURSOR.md');
+
+    return components;
+}
+
+module.exports = {
+    countFilesRecursive,
+    formatSize,
+    calculateInstallSize,
+    getComponentPaths,
+};