synapsexcoder 6.0.0

package/dist/context/context-system.js

@@ -0,0 +1,880 @@
+/**
+ * Context System - Pattern Learning and Knowledge Management
+ *
+ * Inspired by OpenAgentsControl's context system for learning user patterns
+ * and providing context-aware code generation.
+ */
+import { v4 as uuidv4 } from "uuid";
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync, } from "fs";
+import { join, extname } from "path";
+import { homedir } from "os";
+export class ContextSystem {
+    contextDir;
+    projectRoot;
+    projectContext;
+    globalPatterns = [];
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot ?? null;
+        this.contextDir = projectRoot
+            ? join(projectRoot, ".synapsexcoder", "context")
+            : join(homedir(), ".synapsexcoder", "context");
+        // Ensure directories exist
+        if (!existsSync(this.contextDir)) {
+            mkdirSync(this.contextDir, { recursive: true });
+        }
+        this.projectContext = this.loadProjectContext();
+        this.loadGlobalPatterns();
+    }
+    // ========================================================================
+    // Project Context Management
+    // ========================================================================
+    loadProjectContext() {
+        const contextPath = join(this.contextDir, "project.json");
+        if (existsSync(contextPath)) {
+            try {
+                const content = readFileSync(contextPath, "utf-8");
+                return JSON.parse(content);
+            }
+            catch (error) {
+                console.warn("Failed to load project context:", error);
+            }
+        }
+        // Create default context
+        return {
+            id: uuidv4(),
+            name: "Unnamed Project",
+            techStack: [],
+            patterns: [],
+            standards: {
+                naming: {},
+                security: [],
+                performance: [],
+                codeQuality: [],
+            },
+            integrations: [],
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            version: 1,
+        };
+    }
+    saveProjectContext() {
+        const contextPath = join(this.contextDir, "project.json");
+        writeFileSync(contextPath, JSON.stringify(this.projectContext, null, 2));
+    }
+    loadGlobalPatterns() {
+        const globalDir = join(homedir(), ".synapsexcoder", "context", "global");
+        if (!existsSync(globalDir)) {
+            return;
+        }
+        // Load global patterns (universal standards)
+        const patternsPath = join(globalDir, "patterns.json");
+        if (existsSync(patternsPath)) {
+            try {
+                const content = readFileSync(patternsPath, "utf-8");
+                this.globalPatterns = JSON.parse(content);
+            }
+            catch (error) {
+                console.warn("Failed to load global patterns:", error);
+            }
+        }
+    }
+    // ========================================================================
+    // Pattern Learning
+    // ========================================================================
+    addPattern(pattern) {
+        const newPattern = {
+            ...pattern,
+            id: uuidv4(),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            version: 1,
+        };
+        this.projectContext.patterns.push(newPattern);
+        this.projectContext.updatedAt = Date.now();
+        this.projectContext.version++;
+        this.saveProjectContext();
+        return newPattern.id;
+    }
+    updatePattern(id, updates) {
+        const pattern = this.projectContext.patterns.find((p) => p.id === id);
+        if (!pattern)
+            return false;
+        Object.assign(pattern, updates, {
+            updatedAt: Date.now(),
+            version: pattern.version + 1,
+        });
+        this.projectContext.updatedAt = Date.now();
+        this.projectContext.version++;
+        this.saveProjectContext();
+        return true;
+    }
+    removePattern(id) {
+        const index = this.projectContext.patterns.findIndex((p) => p.id === id);
+        if (index === -1)
+            return false;
+        this.projectContext.patterns.splice(index, 1);
+        this.projectContext.updatedAt = Date.now();
+        this.projectContext.version++;
+        this.saveProjectContext();
+        return true;
+    }
+    // ========================================================================
+    // Context Discovery
+    // ========================================================================
+    findRelevantPatterns(query) {
+        const allPatterns = [
+            ...this.projectContext.patterns,
+            ...this.globalPatterns,
+        ];
+        let filtered = allPatterns;
+        // Filter by type
+        if (query.type) {
+            filtered = filtered.filter((p) => p.type === query.type);
+        }
+        // Filter by tags
+        if (query.tags && query.tags.length > 0) {
+            filtered = filtered.filter((p) => query.tags.some((tag) => p.tags.includes(tag)));
+        }
+        // Filter by keywords
+        if (query.keywords && query.keywords.length > 0) {
+            filtered = filtered.filter((p) => {
+                const searchText = `${p.name} ${p.description} ${p.tags.join(" ")}`.toLowerCase();
+                return query.keywords.some((keyword) => searchText.includes(keyword.toLowerCase()));
+            });
+        }
+        // Sort by relevance (simple scoring)
+        filtered.sort((a, b) => {
+            let scoreA = 0;
+            let scoreB = 0;
+            // Prefer project patterns over global
+            if (this.projectContext.patterns.includes(a))
+                scoreA += 10;
+            if (this.projectContext.patterns.includes(b))
+                scoreB += 10;
+            // Prefer recently updated
+            scoreA += (a.updatedAt - Date.now()) / (1000 * 60 * 60 * 24); // days ago
+            scoreB += (b.updatedAt - Date.now()) / (1000 * 60 * 60 * 24);
+            return scoreB - scoreA;
+        });
+        return query.limit ? filtered.slice(0, query.limit) : filtered;
+    }
+    // ========================================================================
+    // Project Configuration
+    // ========================================================================
+    updateProjectInfo(updates) {
+        Object.assign(this.projectContext, updates, {
+            updatedAt: Date.now(),
+            version: this.projectContext.version + 1,
+        });
+        this.saveProjectContext();
+    }
+    getProjectContext() {
+        return { ...this.projectContext };
+    }
+    // ========================================================================
+    // Context Generation for AI
+    // ========================================================================
+    generateContextPrompt(taskDescription, codeContext) {
+        const relevantPatterns = this.findRelevantPatterns({
+            keywords: this.extractKeywords(taskDescription),
+            limit: 5,
+        });
+        let context = "";
+        // Add project info
+        context += `## Project Context\n`;
+        context += `Tech Stack: ${this.projectContext.techStack.join(", ") || "Not specified"}\n\n`;
+        // Add relevant patterns
+        if (relevantPatterns.length > 0) {
+            context += `## Relevant Patterns\n`;
+            for (const pattern of relevantPatterns) {
+                context += `### ${pattern.name}\n`;
+                context += `${pattern.description}\n\n`;
+                if (pattern.examples.length > 0) {
+                    context += `Example:\n${pattern.examples[0].input}\n\n`;
+                    context += `Result: ${pattern.examples[0].output}\n\n`;
+                }
+                context += `Tags: ${pattern.tags.join(", ")}\n\n`;
+            }
+        }
+        // Add standards
+        const standards = this.projectContext.standards;
+        if (Object.keys(standards.naming).length > 0 ||
+            standards.security.length > 0 ||
+            standards.performance.length > 0 ||
+            standards.codeQuality.length > 0) {
+            context += `## Project Standards\n`;
+            if (Object.keys(standards.naming).length > 0) {
+                context += `Naming: ${Object.entries(standards.naming)
+                    .map(([k, v]) => `${k}: ${v}`)
+                    .join(", ")}\n`;
+            }
+            if (standards.security.length > 0) {
+                context += `Security: ${standards.security.join(", ")}\n`;
+            }
+            if (standards.performance.length > 0) {
+                context += `Performance: ${standards.performance.join(", ")}\n`;
+            }
+            if (standards.codeQuality.length > 0) {
+                context += `Code Quality: ${standards.codeQuality.join(", ")}\n`;
+            }
+            context += "\n";
+        }
+        // Add code context if provided
+        if (codeContext && codeContext.length > 0) {
+            context += `## Current Code Context\n`;
+            context += codeContext.join("\n\n");
+            context += "\n\n";
+        }
+        return context;
+    }
+    extractKeywords(text) {
+        // Simple keyword extraction - split by spaces and filter common words
+        const words = text.toLowerCase().split(/\W+/);
+        const stopWords = new Set([
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+            "of",
+            "with",
+            "by",
+            "is",
+            "are",
+            "was",
+            "were",
+            "be",
+            "been",
+            "being",
+            "have",
+            "has",
+            "had",
+            "do",
+            "does",
+            "did",
+            "will",
+            "would",
+            "could",
+            "should",
+            "may",
+            "might",
+            "must",
+            "can",
+            "this",
+            "that",
+            "these",
+            "those",
+        ]);
+        return words.filter((word) => word.length > 2 && !stopWords.has(word));
+    }
+    // ========================================================================
+    // Interactive Context Building
+    // ========================================================================
+    /**
+     * Collect shallow directory entries (files and dirs) for a given path.
+     * Returns empty array on any error (permission denied, missing dir, etc.).
+     */
+    safeReadDir(dirPath) {
+        try {
+            return readdirSync(dirPath, { withFileTypes: true }).map((e) => ({
+                name: e.name,
+                isDir: e.isDirectory(),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Safely read a text file. Returns null on any error.
+     */
+    safeReadFile(filePath) {
+        try {
+            return readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Walk source directories up to `maxDepth` and collect file paths.
+     * Skips common non-source directories for speed.
+     */
+    collectSourceFiles(root, maxDepth = 3) {
+        const skipDirs = new Set([
+            "node_modules",
+            ".git",
+            "dist",
+            "build",
+            ".next",
+            ".nuxt",
+            ".svelte-kit",
+            "coverage",
+            "__pycache__",
+            ".venv",
+            "venv",
+            "target",
+            "vendor",
+            "bin",
+            "obj",
+            ".synapsexcoder",
+        ]);
+        const results = [];
+        const maxFiles = 500; // cap to keep detection fast
+        const walk = (dir, depth) => {
+            if (depth > maxDepth || results.length >= maxFiles)
+                return;
+            for (const entry of this.safeReadDir(dir)) {
+                if (results.length >= maxFiles)
+                    return;
+                const full = join(dir, entry.name);
+                if (entry.isDir) {
+                    if (!skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
+                        walk(full, depth + 1);
+                    }
+                }
+                else {
+                    results.push(full);
+                }
+            }
+        };
+        walk(root, 0);
+        return results;
+    }
+    // ── Tech-Stack Detection ───────────────────────────────────────────────
+    /**
+     * Auto-detect the project's technology stack by inspecting config files
+     * and, as a fallback, file-extension frequency analysis.
+     */
+    detectTechStack(root) {
+        const stack = new Set();
+        // --- 1. package.json (Node / JS ecosystem) ---
+        const pkgRaw = this.safeReadFile(join(root, "package.json"));
+        if (pkgRaw) {
+            try {
+                const pkg = JSON.parse(pkgRaw);
+                const allDeps = {
+                    ...pkg.dependencies,
+                    ...pkg.devDependencies,
+                };
+                // Core runtimes
+                stack.add("Node.js");
+                if (allDeps["typescript"] || existsSync(join(root, "tsconfig.json"))) {
+                    stack.add("TypeScript");
+                }
+                else {
+                    stack.add("JavaScript");
+                }
+                // Frameworks / major libs (order matters — check specific first)
+                const depMap = {
+                    next: "Next.js",
+                    nuxt: "Nuxt",
+                    nuxt3: "Nuxt",
+                    "@angular/core": "Angular",
+                    vue: "Vue",
+                    svelte: "Svelte",
+                    "@sveltejs/kit": "SvelteKit",
+                    react: "React",
+                    "react-native": "React Native",
+                    express: "Express",
+                    fastify: "Fastify",
+                    hono: "Hono",
+                    koa: "Koa",
+                    "nestjs/core": "NestJS",
+                    "@nestjs/core": "NestJS",
+                    electron: "Electron",
+                    "apollo-server": "Apollo GraphQL",
+                    "@apollo/server": "Apollo GraphQL",
+                    graphql: "GraphQL",
+                    prisma: "Prisma",
+                    "@prisma/client": "Prisma",
+                    drizzle: "Drizzle ORM",
+                    "drizzle-orm": "Drizzle ORM",
+                    mongoose: "Mongoose",
+                    sequelize: "Sequelize",
+                    tailwindcss: "Tailwind CSS",
+                    "styled-components": "styled-components",
+                    "@emotion/react": "Emotion",
+                    redux: "Redux",
+                    "@reduxjs/toolkit": "Redux Toolkit",
+                    zustand: "Zustand",
+                    mobx: "MobX",
+                    zod: "Zod",
+                    vitest: "Vitest",
+                    jest: "Jest",
+                    mocha: "Mocha",
+                    playwright: "Playwright",
+                    cypress: "Cypress",
+                    storybook: "Storybook",
+                    "@storybook/react": "Storybook",
+                    webpack: "Webpack",
+                    vite: "Vite",
+                    esbuild: "esbuild",
+                    turbo: "Turborepo",
+                };
+                for (const [dep, label] of Object.entries(depMap)) {
+                    if (dep in allDeps)
+                        stack.add(label);
+                }
+            }
+            catch {
+                // malformed package.json — continue
+            }
+        }
+        // --- 2. tsconfig.json ---
+        if (existsSync(join(root, "tsconfig.json"))) {
+            stack.add("TypeScript");
+        }
+        // --- 3. Cargo.toml → Rust ---
+        if (existsSync(join(root, "Cargo.toml")))
+            stack.add("Rust");
+        // --- 4. go.mod → Go ---
+        if (existsSync(join(root, "go.mod")))
+            stack.add("Go");
+        // --- 5. Python indicators ---
+        if (existsSync(join(root, "requirements.txt")) ||
+            existsSync(join(root, "pyproject.toml")) ||
+            existsSync(join(root, "setup.py")) ||
+            existsSync(join(root, "Pipfile"))) {
+            stack.add("Python");
+            // Check for common Python frameworks
+            const reqRaw = this.safeReadFile(join(root, "requirements.txt")) ??
+                this.safeReadFile(join(root, "pyproject.toml")) ??
+                "";
+            if (/django/i.test(reqRaw))
+                stack.add("Django");
+            if (/flask/i.test(reqRaw))
+                stack.add("Flask");
+            if (/fastapi/i.test(reqRaw))
+                stack.add("FastAPI");
+            if (/pytorch|torch/i.test(reqRaw))
+                stack.add("PyTorch");
+            if (/tensorflow/i.test(reqRaw))
+                stack.add("TensorFlow");
+        }
+        // --- 6. Ruby ---
+        if (existsSync(join(root, "Gemfile"))) {
+            stack.add("Ruby");
+            const gemRaw = this.safeReadFile(join(root, "Gemfile")) ?? "";
+            if (/rails/i.test(gemRaw))
+                stack.add("Ruby on Rails");
+        }
+        // --- 7. C# / .NET ---
+        const rootEntries = this.safeReadDir(root);
+        if (rootEntries.some((e) => !e.isDir &&
+            (e.name.endsWith(".sln") ||
+                e.name.endsWith(".csproj") ||
+                e.name.endsWith(".fsproj")))) {
+            stack.add("C#/.NET");
+        }
+        // --- 8. Java ---
+        if (existsSync(join(root, "pom.xml")) ||
+            existsSync(join(root, "build.gradle")) ||
+            existsSync(join(root, "build.gradle.kts"))) {
+            stack.add("Java");
+        }
+        // --- 9. Docker ---
+        if (existsSync(join(root, "Dockerfile")) ||
+            existsSync(join(root, "docker-compose.yml")) ||
+            existsSync(join(root, "docker-compose.yaml"))) {
+            stack.add("Docker");
+        }
+        // --- 10. File-extension frequency fallback (only if nothing detected yet) ---
+        if (stack.size === 0) {
+            const extCounts = new Map();
+            const files = this.collectSourceFiles(root, 2);
+            for (const f of files) {
+                const ext = extname(f).toLowerCase();
+                if (ext)
+                    extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+            }
+            const extToLang = {
+                ".ts": "TypeScript",
+                ".tsx": "TypeScript",
+                ".js": "JavaScript",
+                ".jsx": "JavaScript",
+                ".py": "Python",
+                ".rs": "Rust",
+                ".go": "Go",
+                ".rb": "Ruby",
+                ".java": "Java",
+                ".cs": "C#",
+                ".cpp": "C++",
+                ".c": "C",
+                ".swift": "Swift",
+                ".kt": "Kotlin",
+                ".php": "PHP",
+                ".dart": "Dart",
+            };
+            // Pick the top 3 extensions by count
+            const sorted = [...extCounts.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3);
+            for (const [ext] of sorted) {
+                if (extToLang[ext])
+                    stack.add(extToLang[ext]);
+            }
+        }
+        return [...stack];
+    }
+    // ── API-Pattern Detection ──────────────────────────────────────────────
+    /**
+     * Auto-detect API patterns by sampling source files for common
+     * route/handler/schema definitions.
+     */
+    detectApiPatterns(root) {
+        const signals = [];
+        const files = this.collectSourceFiles(root, 3);
+        let hasExpressRoutes = false;
+        let hasFastifyRoutes = false;
+        let hasNextApiRoutes = false;
+        let hasGraphQL = false;
+        let hasGrpc = false;
+        let hasTrpc = false;
+        let hasMiddleware = false;
+        let hasValidation = false;
+        let hasOpenApi = false;
+        for (const filePath of files) {
+            const name = filePath.toLowerCase();
+            // Next.js API routes (app dir: route.ts, pages dir: /api/)
+            if (name.includes("/api/") &&
+                (name.endsWith("route.ts") ||
+                    name.endsWith("route.js") ||
+                    name.endsWith("/api/") === false)) {
+                hasNextApiRoutes = true;
+            }
+            // GraphQL schema files
+            if (name.endsWith(".graphql") || name.endsWith(".gql")) {
+                hasGraphQL = true;
+            }
+            // gRPC proto files
+            if (name.endsWith(".proto")) {
+                hasGrpc = true;
+            }
+            // Only read a subset of source files to keep it fast
+            const ext = extname(filePath).toLowerCase();
+            if (![".ts", ".js", ".tsx", ".jsx", ".py", ".rb", ".go"].includes(ext)) {
+                continue;
+            }
+            const content = this.safeReadFile(filePath);
+            if (!content)
+                continue;
+            // Sample only first 3000 chars for speed
+            const sample = content.slice(0, 3000);
+            // Express / Koa / Hono route patterns
+            if (/\b(app|router)\.(get|post|put|patch|delete|use)\s*\(/.test(sample)) {
+                hasExpressRoutes = true;
+            }
+            // Fastify routes
+            if (/\bfastify\.(get|post|put|delete|register)\s*\(/.test(sample)) {
+                hasFastifyRoutes = true;
+            }
+            // GraphQL resolvers / typeDefs
+            if (/\b(typeDefs|resolvers|gql`|makeExecutableSchema)\b/.test(sample)) {
+                hasGraphQL = true;
+            }
+            // tRPC
+            if (/\b(trpc|createTRPCRouter|publicProcedure|protectedProcedure)\b/.test(sample)) {
+                hasTrpc = true;
+            }
+            // Middleware patterns
+            if (/\b(middleware|use\(|next\(\))\b/.test(sample) &&
+                /\b(req|request|ctx|context)\b/.test(sample)) {
+                hasMiddleware = true;
+            }
+            // Validation (Zod, Joi, Yup, class-validator)
+            if (/\b(z\.|Joi\.|yup\.|@IsString|@IsNumber|@Validate)\b/.test(sample)) {
+                hasValidation = true;
+            }
+            // OpenAPI / Swagger
+            if (/\b(swagger|openapi|@ApiProperty|@ApiOperation)\b/i.test(sample)) {
+                hasOpenApi = true;
+            }
+        }
+        // Build human-readable description
+        if (hasNextApiRoutes)
+            signals.push("Next.js API routes (App Router)");
+        if (hasExpressRoutes)
+            signals.push("Express-style route handlers");
+        if (hasFastifyRoutes)
+            signals.push("Fastify route handlers");
+        if (hasTrpc)
+            signals.push("tRPC procedures");
+        if (hasGraphQL)
+            signals.push("GraphQL schema + resolvers");
+        if (hasGrpc)
+            signals.push("gRPC services");
+        if (hasOpenApi)
+            signals.push("OpenAPI/Swagger documentation");
+        if (hasMiddleware)
+            signals.push("middleware pipeline");
+        if (hasValidation)
+            signals.push("request validation");
+        if (signals.length === 0) {
+            // Fallback: check if there are any API-like directories
+            const entries = this.safeReadDir(root);
+            const hasApiDir = entries.some((e) => e.isDir &&
+                ["api", "routes", "controllers", "handlers"].includes(e.name.toLowerCase()));
+            if (hasApiDir) {
+                return "RESTful endpoints (detected API directory structure)";
+            }
+            return "No specific API pattern detected";
+        }
+        return signals.join(", ");
+    }
+    // ── UI-Pattern Detection ───────────────────────────────────────────────
+    /**
+     * Auto-detect UI/component patterns by scanning source files for
+     * framework idioms, styling approaches, and state management.
+     */
+    detectUiPatterns(root) {
+        const signals = [];
+        const files = this.collectSourceFiles(root, 3);
+        let hasClassComponents = false;
+        let hasFunctionalComponents = false;
+        let hasVueSfc = false;
+        let hasVueCompositionApi = false;
+        let hasSvelte = false;
+        let hasCssModules = false;
+        let hasCssInJs = false;
+        let hasTailwind = false;
+        let hasRedux = false;
+        let hasZustand = false;
+        let hasMobx = false;
+        let hasContextApi = false;
+        let hasJotai = false;
+        let hasRecoil = false;
+        // Quick check for Tailwind config at root
+        if (existsSync(join(root, "tailwind.config.js")) ||
+            existsSync(join(root, "tailwind.config.ts")) ||
+            existsSync(join(root, "tailwind.config.mjs")) ||
+            existsSync(join(root, "tailwind.config.cjs"))) {
+            hasTailwind = true;
+        }
+        for (const filePath of files) {
+            const name = filePath.toLowerCase();
+            const ext = extname(filePath).toLowerCase();
+            // Vue SFCs
+            if (ext === ".vue") {
+                hasVueSfc = true;
+                const content = this.safeReadFile(filePath);
+                if (content &&
+                    /\bsetup\s*\(|<script\s+setup/i.test(content.slice(0, 2000))) {
+                    hasVueCompositionApi = true;
+                }
+                continue;
+            }
+            // Svelte components
+            if (ext === ".svelte") {
+                hasSvelte = true;
+                continue;
+            }
+            // CSS modules
+            if (name.endsWith(".module.css") || name.endsWith(".module.scss")) {
+                hasCssModules = true;
+                continue;
+            }
+            // Only parse JS/TS for deeper analysis
+            if (![".ts", ".tsx", ".js", ".jsx"].includes(ext))
+                continue;
+            const content = this.safeReadFile(filePath);
+            if (!content)
+                continue;
+            const sample = content.slice(0, 3000);
+            // React class components
+            if (/\bclass\s+\w+\s+extends\s+(React\.)?Component\b/.test(sample) ||
+                /\bclass\s+\w+\s+extends\s+(React\.)?PureComponent\b/.test(sample)) {
+                hasClassComponents = true;
+            }
+            // React functional components (hooks usage is a strong signal)
+            if (/\b(useState|useEffect|useCallback|useMemo|useRef|useContext)\b/.test(sample)) {
+                hasFunctionalComponents = true;
+            }
+            // styled-components / Emotion
+            if (/\b(styled\.|css`|styled\(|@emotion)\b/.test(sample)) {
+                hasCssInJs = true;
+            }
+            // Tailwind class names in JSX
+            if (!hasTailwind &&
+                /className=["'`][^"'`]*\b(flex|grid|p-|m-|text-|bg-|rounded)\b/.test(sample)) {
+                hasTailwind = true;
+            }
+            // State management
+            if (/\b(useSelector|useDispatch|createSlice|configureStore)\b/.test(sample)) {
+                hasRedux = true;
+            }
+            if (/\bcreate\s*\(\s*\(set\b|\buseStore\b/.test(sample) ||
+                /\bfrom\s+['"]zustand['"]/.test(sample)) {
+                hasZustand = true;
+            }
+            if (/\b(observable|makeObservable|makeAutoObservable|observer\()\b/.test(sample)) {
+                hasMobx = true;
+            }
+            if (/\b(createContext|useContext)\b/.test(sample) &&
+                /\bProvider\b/.test(sample)) {
+                hasContextApi = true;
+            }
+            if (/\b(atom|useAtom)\b/.test(sample) && /jotai/i.test(sample)) {
+                hasJotai = true;
+            }
+            if (/\b(atom|selector|useRecoilState|useRecoilValue)\b/.test(sample) &&
+                /recoil/i.test(sample)) {
+                hasRecoil = true;
+            }
+        }
+        // Build description
+        // Component style
+        if (hasFunctionalComponents && hasClassComponents) {
+            signals.push("React (mixed class + functional components)");
+        }
+        else if (hasFunctionalComponents) {
+            signals.push("Functional React components with hooks");
+        }
+        else if (hasClassComponents) {
+            signals.push("React class components");
+        }
+        if (hasVueSfc) {
+            signals.push(hasVueCompositionApi
+                ? "Vue SFCs with Composition API"
+                : "Vue Single-File Components");
+        }
+        if (hasSvelte)
+            signals.push("Svelte components");
+        // Styling
+        const stylingSignals = [];
+        if (hasTailwind)
+            stylingSignals.push("Tailwind CSS");
+        if (hasCssInJs)
+            stylingSignals.push("CSS-in-JS");
+        if (hasCssModules)
+            stylingSignals.push("CSS Modules");
+        if (stylingSignals.length > 0) {
+            signals.push(`Styling: ${stylingSignals.join(", ")}`);
+        }
+        // State management
+        const stateSignals = [];
+        if (hasRedux)
+            stateSignals.push("Redux");
+        if (hasZustand)
+            stateSignals.push("Zustand");
+        if (hasMobx)
+            stateSignals.push("MobX");
+        if (hasContextApi)
+            stateSignals.push("Context API");
+        if (hasJotai)
+            stateSignals.push("Jotai");
+        if (hasRecoil)
+            stateSignals.push("Recoil");
+        if (stateSignals.length > 0) {
+            signals.push(`State: ${stateSignals.join(", ")}`);
+        }
+        if (signals.length === 0) {
+            return "No specific UI framework pattern detected";
+        }
+        return signals.join("; ");
+    }
+    // ── Build Context ──────────────────────────────────────────────────────
+    async buildContextInteractively() {
+        console.log("🧠 Building project context...\n");
+        // Resolve the project root for auto-detection.
+        // If no projectRoot was provided at construction time, fall back to cwd.
+        const root = this.projectRoot ?? process.cwd();
+        // ── Auto-detect tech stack ───────────────────────────────────────────
+        console.log("🔍 Auto-detecting tech stack...");
+        const techStack = this.detectTechStack(root);
+        if (techStack.length > 0) {
+            console.log(`   Detected: ${techStack.join(", ")}`);
+        }
+        else {
+            console.log("   No specific tech stack detected — using defaults");
+        }
+        // ── Auto-detect API patterns ─────────────────────────────────────────
+        console.log("🔍 Auto-detecting API patterns...");
+        const apiPattern = this.detectApiPatterns(root);
+        console.log(`   Detected: ${apiPattern}`);
+        // ── Auto-detect UI patterns ──────────────────────────────────────────
+        console.log("🔍 Auto-detecting UI/component patterns...");
+        const uiPattern = this.detectUiPatterns(root);
+        console.log(`   Detected: ${uiPattern}`);
+        // ── Detect code-quality tooling ──────────────────────────────────────
+        const codeQuality = [];
+        if (techStack.includes("TypeScript"))
+            codeQuality.push("TypeScript strict mode");
+        if (existsSync(join(root, ".eslintrc.js")) ||
+            existsSync(join(root, ".eslintrc.json")) ||
+            existsSync(join(root, ".eslintrc.cjs")) ||
+            existsSync(join(root, "eslint.config.js")) ||
+            existsSync(join(root, "eslint.config.mjs"))) {
+            codeQuality.push("ESLint");
+        }
+        if (existsSync(join(root, ".prettierrc")) ||
+            existsSync(join(root, ".prettierrc.json")) ||
+            existsSync(join(root, ".prettierrc.js"))) {
+            codeQuality.push("Prettier");
+        }
+        if (existsSync(join(root, "biome.json")) ||
+            existsSync(join(root, "biome.jsonc"))) {
+            codeQuality.push("Biome");
+        }
+        // ── Persist to project context ───────────────────────────────────────
+        this.updateProjectInfo({
+            techStack,
+            standards: {
+                ...this.projectContext.standards,
+                codeQuality: codeQuality.length > 0
+                    ? codeQuality
+                    : this.projectContext.standards.codeQuality,
+            },
+        });
+        // Add API pattern
+        this.addPattern({
+            type: "api",
+            name: "API Endpoint Pattern",
+            description: apiPattern,
+            examples: [
+                {
+                    input: "Create user endpoint",
+                    output: "app/api/users/route.ts with POST handler",
+                    explanation: "Standard RESTful endpoint structure",
+                },
+            ],
+            tags: ["api", "backend", "rest"],
+        });
+        // Add UI pattern only if a UI framework was detected
+        if (uiPattern !== "No specific UI framework pattern detected" &&
+            techStack.some((t) => /react|vue|svelte|angular/i.test(t))) {
+            this.addPattern({
+                type: "ui",
+                name: "Component Pattern",
+                description: uiPattern,
+                examples: [
+                    {
+                        input: "Create user profile component",
+                        output: "components/UserProfile.tsx with TypeScript interfaces",
+                        explanation: "Standard component structure with props interface",
+                    },
+                ],
+                tags: ["ui", "frontend", "components"],
+            });
+        }
+        console.log("\n✅ Context built successfully!");
+        console.log(`   Tech stack: ${techStack.join(", ") || "(none)"}`);
+        console.log(`   API patterns: ${apiPattern}`);
+        console.log(`   UI patterns: ${uiPattern}`);
+        console.log(`   Code quality: ${codeQuality.join(", ") || "(none)"}`);
+        console.log(`   Patterns added: ${this.projectContext.patterns.length}`);
+    }
+}
+// ========================================================================
+// Factory Function
+// ========================================================================
+export function createContextSystem(projectRoot) {
+    return new ContextSystem(projectRoot);
+}
+//# sourceMappingURL=context-system.js.map