@neurcode-ai/cli 0.8.3 → 0.8.5

package/dist/services/project-knowledge-service.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Project Knowledge Service
+ *
+ * Detects and maintains persistent knowledge about project tech stack and architecture.
+ * This service provides context-aware information that helps the Architect make better decisions.
+ *
+ * Features:
+ * - Tech stack detection (Node.js, Python, Go)
+ * - Architecture pattern detection and memory
+ * - Persistent storage in .neurcode/architecture.json
+ * - Natural language project summaries
+ */
+import { z } from 'zod';
+/**
+ * Architecture pattern types
+ */
+export type ArchitecturePattern = 'feature-based' | 'layered' | 'mvc' | 'unknown';
+/**
+ * Architecture memory schema
+ */
+declare const ArchitectureMemorySchema: z.ZodObject<{
+    pattern: z.ZodEnum<{
+        unknown: "unknown";
+        "feature-based": "feature-based";
+        layered: "layered";
+        mvc: "mvc";
+    }>;
+    invariants: z.ZodArray<z.ZodString>;
+    domainBoundaries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ArchitectureMemory = z.infer<typeof ArchitectureMemorySchema>;
+/**
+ * Tech stack information
+ */
+export interface TechStack {
+    language: 'node' | 'python' | 'go' | 'unknown';
+    framework?: string;
+    orm?: string;
+    styling?: string;
+    buildTool?: string;
+    packageManager?: string;
+    version?: string;
+}
+/**
+ * Project summary combining tech stack and architecture
+ */
+export interface ProjectSummary {
+    techStack: TechStack;
+    architecture: ArchitectureMemory;
+    summary: string;
+}
+export declare class ProjectKnowledgeService {
+    /**
+     * Detect tech stack from project root
+     */
+    detectTechStack(rootPath: string): Promise<TechStack>;
+    /**
+     * Detect Node.js framework from package.json
+     */
+    private detectNodeFramework;
+    /**
+     * Detect Node.js ORM from package.json
+     */
+    private detectNodeORM;
+    /**
+     * Detect styling library from package.json
+     */
+    private detectStyling;
+    /**
+     * Detect build tool from package.json
+     */
+    private detectBuildTool;
+    /**
+     * Detect package manager from lock files
+     */
+    private detectPackageManager;
+    /**
+     * Detect Python framework from requirements.txt
+     */
+    private detectPythonFramework;
+    /**
+     * Detect Python ORM from requirements.txt
+     */
+    private detectPythonORM;
+    /**
+     * Detect Go framework from go.mod
+     */
+    private detectGoFramework;
+    /**
+     * Detect Go ORM from go.mod
+     */
+    private detectGoORM;
+    /**
+     * Detect architecture pattern from folder structure
+     */
+    private detectArchitecturePattern;
+    /**
+     * Detect domain boundaries from folder structure
+     */
+    private detectDomainBoundaries;
+    /**
+     * Generate default invariants based on architecture pattern
+     */
+    private generateDefaultInvariants;
+    /**
+     * Read architecture memory from .neurcode/architecture.json
+     */
+    readArchitectureMemory(rootPath: string): Promise<ArchitectureMemory | null>;
+    /**
+     * Write architecture memory to .neurcode/architecture.json
+     */
+    writeArchitectureMemory(rootPath: string, memory: ArchitectureMemory): Promise<void>;
+    /**
+     * Initialize architecture memory with defaults based on folder structure
+     */
+    initializeArchitectureMemory(rootPath: string): Promise<ArchitectureMemory>;
+    /**
+     * Get or create architecture memory (reads from disk or initializes)
+     */
+    getArchitectureMemory(rootPath: string): Promise<ArchitectureMemory>;
+    /**
+     * Generate natural language project summary
+     */
+    getProjectSummary(rootPath: string): Promise<ProjectSummary>;
+}
+export {};
+//# sourceMappingURL=project-knowledge-service.d.ts.map

package/dist/services/project-knowledge-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-knowledge-service.d.ts","sourceRoot":"","sources":["../../src/services/project-knowledge-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,CAAC;AAElF;;GAEG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;iBAI5B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,kBAAkB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,uBAAuB;IAClC;;OAEG;IACG,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IA6F3D;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwC3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAqCjC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA8BjC;;OAEG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAmBlF;;OAEG;IACG,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB1F;;OAEG;IACG,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAiBjF;;OAEG;IACG,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAW1E;;OAEG;IACG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;CAgEnE"}

package/dist/services/project-knowledge-service.js

@@ -0,0 +1,535 @@
+"use strict";
+/**
+ * Project Knowledge Service
+ *
+ * Detects and maintains persistent knowledge about project tech stack and architecture.
+ * This service provides context-aware information that helps the Architect make better decisions.
+ *
+ * Features:
+ * - Tech stack detection (Node.js, Python, Go)
+ * - Architecture pattern detection and memory
+ * - Persistent storage in .neurcode/architecture.json
+ * - Natural language project summaries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectKnowledgeService = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const zod_1 = require("zod");
+/**
+ * Architecture memory schema
+ */
+const ArchitectureMemorySchema = zod_1.z.object({
+    pattern: zod_1.z.enum(['feature-based', 'layered', 'mvc', 'unknown']),
+    invariants: zod_1.z.array(zod_1.z.string()),
+    domainBoundaries: zod_1.z.array(zod_1.z.string()),
+});
+class ProjectKnowledgeService {
+    /**
+     * Detect tech stack from project root
+     */
+    async detectTechStack(rootPath) {
+        const techStack = {
+            language: 'unknown',
+        };
+        // Try Node.js (package.json)
+        const packageJsonPath = (0, path_1.join)(rootPath, 'package.json');
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+                techStack.language = 'node';
+                techStack.packageManager = this.detectPackageManager(rootPath);
+                techStack.version = packageJson.version;
+                // Detect framework
+                techStack.framework = this.detectNodeFramework(packageJson);
+                // Detect ORM
+                techStack.orm = this.detectNodeORM(packageJson);
+                // Detect styling
+                techStack.styling = this.detectStyling(packageJson);
+                // Detect build tool
+                techStack.buildTool = this.detectBuildTool(packageJson);
+                return techStack;
+            }
+            catch (error) {
+                console.warn('Failed to parse package.json:', error);
+            }
+        }
+        // Try Python (requirements.txt or pyproject.toml)
+        const requirementsPath = (0, path_1.join)(rootPath, 'requirements.txt');
+        const pyprojectPath = (0, path_1.join)(rootPath, 'pyproject.toml');
+        if ((0, fs_1.existsSync)(requirementsPath) || (0, fs_1.existsSync)(pyprojectPath)) {
+            techStack.language = 'python';
+            if ((0, fs_1.existsSync)(requirementsPath)) {
+                try {
+                    const requirements = (0, fs_1.readFileSync)(requirementsPath, 'utf-8');
+                    techStack.framework = this.detectPythonFramework(requirements);
+                    techStack.orm = this.detectPythonORM(requirements);
+                }
+                catch (error) {
+                    console.warn('Failed to read requirements.txt:', error);
+                }
+            }
+            if ((0, fs_1.existsSync)(pyprojectPath)) {
+                try {
+                    const pyproject = (0, fs_1.readFileSync)(pyprojectPath, 'utf-8');
+                    // Simple parsing for pyproject.toml (basic implementation)
+                    if (pyproject.includes('django')) {
+                        techStack.framework = 'Django';
+                    }
+                    else if (pyproject.includes('fastapi')) {
+                        techStack.framework = 'FastAPI';
+                    }
+                    else if (pyproject.includes('flask')) {
+                        techStack.framework = 'Flask';
+                    }
+                }
+                catch (error) {
+                    console.warn('Failed to read pyproject.toml:', error);
+                }
+            }
+            return techStack;
+        }
+        // Try Go (go.mod)
+        const goModPath = (0, path_1.join)(rootPath, 'go.mod');
+        if ((0, fs_1.existsSync)(goModPath)) {
+            try {
+                const goMod = (0, fs_1.readFileSync)(goModPath, 'utf-8');
+                techStack.language = 'go';
+                // Extract module name and version
+                const moduleMatch = goMod.match(/^module\s+(\S+)/m);
+                if (moduleMatch) {
+                    techStack.version = moduleMatch[1];
+                }
+                // Detect Go framework
+                techStack.framework = this.detectGoFramework(goMod);
+                techStack.orm = this.detectGoORM(goMod);
+                return techStack;
+            }
+            catch (error) {
+                console.warn('Failed to read go.mod:', error);
+            }
+        }
+        return techStack;
+    }
+    /**
+     * Detect Node.js framework from package.json
+     */
+    detectNodeFramework(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // React frameworks
+        if (deps['next'])
+            return 'Next.js';
+        if (deps['remix'])
+            return 'Remix';
+        if (deps['gatsby'])
+            return 'Gatsby';
+        if (deps['react']) {
+            // Check for Vite
+            if (deps['vite'])
+                return 'React + Vite';
+            if (deps['@vitejs/plugin-react'])
+                return 'React + Vite';
+            return 'React';
+        }
+        // Vue frameworks
+        if (deps['nuxt'])
+            return 'Nuxt.js';
+        if (deps['vue'])
+            return 'Vue.js';
+        // Angular
+        if (deps['@angular/core'])
+            return 'Angular';
+        // Backend frameworks
+        if (deps['express'])
+            return 'Express';
+        if (deps['fastify'])
+            return 'Fastify';
+        if (deps['koa'])
+            return 'Koa';
+        if (deps['nest'])
+            return 'NestJS';
+        if (deps['hapi'])
+            return 'Hapi';
+        // Check scripts for framework hints
+        if (packageJson.scripts) {
+            if (packageJson.scripts.dev?.includes('next'))
+                return 'Next.js';
+            if (packageJson.scripts.start?.includes('next'))
+                return 'Next.js';
+        }
+        return undefined;
+    }
+    /**
+     * Detect Node.js ORM from package.json
+     */
+    detectNodeORM(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        if (deps['prisma'])
+            return 'Prisma';
+        if (deps['typeorm'])
+            return 'TypeORM';
+        if (deps['sequelize'])
+            return 'Sequelize';
+        if (deps['mongoose'])
+            return 'Mongoose';
+        if (deps['drizzle-orm'])
+            return 'Drizzle ORM';
+        if (deps['kysely'])
+            return 'Kysely';
+        return undefined;
+    }
+    /**
+     * Detect styling library from package.json
+     */
+    detectStyling(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        if (deps['tailwindcss'])
+            return 'Tailwind CSS';
+        if (deps['@mui/material'] || deps['@material-ui/core'])
+            return 'Material UI';
+        if (deps['styled-components'])
+            return 'Styled Components';
+        if (deps['emotion'])
+            return 'Emotion';
+        if (deps['sass'] || deps['node-sass'])
+            return 'Sass';
+        if (deps['less'])
+            return 'Less';
+        if (deps['bootstrap'])
+            return 'Bootstrap';
+        return undefined;
+    }
+    /**
+     * Detect build tool from package.json
+     */
+    detectBuildTool(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        if (deps['vite'])
+            return 'Vite';
+        if (deps['webpack'])
+            return 'Webpack';
+        if (deps['rollup'])
+            return 'Rollup';
+        if (deps['esbuild'])
+            return 'esbuild';
+        if (deps['turbo'])
+            return 'Turborepo';
+        if (deps['nx'])
+            return 'Nx';
+        return undefined;
+    }
+    /**
+     * Detect package manager from lock files
+     */
+    detectPackageManager(rootPath) {
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'pnpm-lock.yaml')))
+            return 'pnpm';
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'yarn.lock')))
+            return 'yarn';
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'package-lock.json')))
+            return 'npm';
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'bun.lockb')))
+            return 'bun';
+        return undefined;
+    }
+    /**
+     * Detect Python framework from requirements.txt
+     */
+    detectPythonFramework(requirements) {
+        const lowerRequirements = requirements.toLowerCase();
+        if (lowerRequirements.includes('django'))
+            return 'Django';
+        if (lowerRequirements.includes('fastapi'))
+            return 'FastAPI';
+        if (lowerRequirements.includes('flask'))
+            return 'Flask';
+        if (lowerRequirements.includes('tornado'))
+            return 'Tornado';
+        if (lowerRequirements.includes('bottle'))
+            return 'Bottle';
+        return undefined;
+    }
+    /**
+     * Detect Python ORM from requirements.txt
+     */
+    detectPythonORM(requirements) {
+        const lowerRequirements = requirements.toLowerCase();
+        if (lowerRequirements.includes('sqlalchemy'))
+            return 'SQLAlchemy';
+        if (lowerRequirements.includes('django') && lowerRequirements.includes('orm'))
+            return 'Django ORM';
+        if (lowerRequirements.includes('peewee'))
+            return 'Peewee';
+        if (lowerRequirements.includes('tortoise-orm'))
+            return 'Tortoise ORM';
+        if (lowerRequirements.includes('prisma') || lowerRequirements.includes('prisma-client'))
+            return 'Prisma';
+        return undefined;
+    }
+    /**
+     * Detect Go framework from go.mod
+     */
+    detectGoFramework(goMod) {
+        if (goMod.includes('github.com/gin-gonic/gin'))
+            return 'Gin';
+        if (goMod.includes('github.com/gorilla/mux'))
+            return 'Gorilla Mux';
+        if (goMod.includes('github.com/labstack/echo'))
+            return 'Echo';
+        if (goMod.includes('github.com/go-chi/chi'))
+            return 'Chi';
+        if (goMod.includes('github.com/beego/beego'))
+            return 'Beego';
+        return undefined;
+    }
+    /**
+     * Detect Go ORM from go.mod
+     */
+    detectGoORM(goMod) {
+        if (goMod.includes('gorm.io/gorm'))
+            return 'GORM';
+        if (goMod.includes('github.com/jinzhu/gorm'))
+            return 'GORM (legacy)';
+        if (goMod.includes('github.com/volatiletech/sqlboiler'))
+            return 'SQLBoiler';
+        if (goMod.includes('github.com/go-pg/pg'))
+            return 'go-pg';
+        return undefined;
+    }
+    /**
+     * Detect architecture pattern from folder structure
+     */
+    detectArchitecturePattern(rootPath) {
+        // Check for Next.js App Router structure
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'app')) || (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'app'))) {
+            return 'feature-based'; // Next.js App Router uses feature-based routing
+        }
+        // Check for feature-based structure (modules, features, domains)
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'modules')) ||
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'features')) ||
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'domains'))) {
+            return 'feature-based';
+        }
+        // Check for layered architecture (controllers, services, models)
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'controllers')) &&
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'services')) &&
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'models'))) {
+            return 'layered';
+        }
+        // Check for MVC structure
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'models')) &&
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'views')) &&
+            (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src', 'controllers'))) {
+            return 'mvc';
+        }
+        // Check for Django-like structure (apps)
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'apps')) ||
+            ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'src')) &&
+                (0, fs_1.existsSync)((0, path_1.join)(rootPath, 'manage.py')))) {
+            return 'feature-based';
+        }
+        return 'unknown';
+    }
+    /**
+     * Detect domain boundaries from folder structure
+     */
+    detectDomainBoundaries(rootPath) {
+        const boundaries = [];
+        // Check common patterns
+        const srcPath = (0, path_1.join)(rootPath, 'src');
+        if ((0, fs_1.existsSync)(srcPath)) {
+            // Feature-based boundaries
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'modules'))) {
+                boundaries.push('src/modules/*');
+            }
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'features'))) {
+                boundaries.push('src/features/*');
+            }
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'domains'))) {
+                boundaries.push('src/domains/*');
+            }
+            // App Router (Next.js)
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'app'))) {
+                boundaries.push('src/app/**/route.ts');
+                boundaries.push('src/app/**/page.tsx');
+            }
+            // Layered architecture boundaries
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'controllers'))) {
+                boundaries.push('src/controllers/*');
+            }
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'services'))) {
+                boundaries.push('src/services/*');
+            }
+            if ((0, fs_1.existsSync)((0, path_1.join)(srcPath, 'models'))) {
+                boundaries.push('src/models/*');
+            }
+        }
+        // Django apps
+        if ((0, fs_1.existsSync)((0, path_1.join)(rootPath, 'apps'))) {
+            boundaries.push('apps/*');
+        }
+        return boundaries;
+    }
+    /**
+     * Generate default invariants based on architecture pattern
+     */
+    generateDefaultInvariants(pattern) {
+        const invariants = [];
+        switch (pattern) {
+            case 'layered':
+                invariants.push('No direct database access in controllers');
+                invariants.push('Business logic must be in service layer');
+                invariants.push('Models should only contain data structures');
+                break;
+            case 'mvc':
+                invariants.push('Models should not contain business logic');
+                invariants.push('Views should not contain business logic');
+                invariants.push('Controllers should delegate to services');
+                break;
+            case 'feature-based':
+                invariants.push('Features should be self-contained modules');
+                invariants.push('No cross-feature dependencies without interfaces');
+                invariants.push('Shared code should be in common/shared directory');
+                break;
+            case 'unknown':
+                invariants.push('Follow existing project structure');
+                break;
+        }
+        return invariants;
+    }
+    /**
+     * Read architecture memory from .neurcode/architecture.json
+     */
+    async readArchitectureMemory(rootPath) {
+        const neurcodeDir = (0, path_1.join)(rootPath, '.neurcode');
+        const architecturePath = (0, path_1.join)(neurcodeDir, 'architecture.json');
+        if (!(0, fs_1.existsSync)(architecturePath)) {
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(architecturePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            const validated = ArchitectureMemorySchema.parse(parsed);
+            return validated;
+        }
+        catch (error) {
+            console.warn('Failed to read or validate architecture.json:', error);
+            return null;
+        }
+    }
+    /**
+     * Write architecture memory to .neurcode/architecture.json
+     */
+    async writeArchitectureMemory(rootPath, memory) {
+        const neurcodeDir = (0, path_1.join)(rootPath, '.neurcode');
+        const architecturePath = (0, path_1.join)(neurcodeDir, 'architecture.json');
+        // Ensure .neurcode directory exists
+        if (!(0, fs_1.existsSync)(neurcodeDir)) {
+            (0, fs_1.mkdirSync)(neurcodeDir, { recursive: true });
+        }
+        // Validate before writing
+        const validated = ArchitectureMemorySchema.parse(memory);
+        // Write to file
+        (0, fs_1.writeFileSync)(architecturePath, JSON.stringify(validated, null, 2), 'utf-8');
+    }
+    /**
+     * Initialize architecture memory with defaults based on folder structure
+     */
+    async initializeArchitectureMemory(rootPath) {
+        const pattern = this.detectArchitecturePattern(rootPath);
+        const domainBoundaries = this.detectDomainBoundaries(rootPath);
+        const invariants = this.generateDefaultInvariants(pattern);
+        const memory = {
+            pattern,
+            invariants,
+            domainBoundaries,
+        };
+        // Save to disk
+        await this.writeArchitectureMemory(rootPath, memory);
+        return memory;
+    }
+    /**
+     * Get or create architecture memory (reads from disk or initializes)
+     */
+    async getArchitectureMemory(rootPath) {
+        // Try to read existing
+        const existing = await this.readArchitectureMemory(rootPath);
+        if (existing) {
+            return existing;
+        }
+        // Initialize if not found
+        return await this.initializeArchitectureMemory(rootPath);
+    }
+    /**
+     * Generate natural language project summary
+     */
+    async getProjectSummary(rootPath) {
+        const techStack = await this.detectTechStack(rootPath);
+        const architecture = await this.getArchitectureMemory(rootPath);
+        // Build natural language summary
+        const parts = [];
+        // Tech stack description
+        if (techStack.language !== 'unknown') {
+            const stackParts = [];
+            if (techStack.framework) {
+                stackParts.push(techStack.framework);
+            }
+            else {
+                // Fallback to language name
+                const languageNames = {
+                    node: 'Node.js',
+                    python: 'Python',
+                    go: 'Go',
+                };
+                stackParts.push(languageNames[techStack.language] || techStack.language);
+            }
+            if (techStack.orm) {
+                stackParts.push(`using ${techStack.orm}`);
+            }
+            if (techStack.styling) {
+                stackParts.push(`with ${techStack.styling}`);
+            }
+            if (techStack.buildTool) {
+                stackParts.push(`built with ${techStack.buildTool}`);
+            }
+            parts.push(stackParts.join(' ') + ' project');
+        }
+        else {
+            parts.push('Unknown technology stack');
+        }
+        // Architecture description
+        if (architecture.pattern !== 'unknown') {
+            const patternNames = {
+                'feature-based': 'feature-based architecture',
+                'layered': 'layered architecture',
+                'mvc': 'MVC architecture',
+                'unknown': 'unknown architecture',
+            };
+            parts.push(`Follows ${patternNames[architecture.pattern]}`);
+        }
+        // Add invariants if present
+        if (architecture.invariants.length > 0) {
+            parts.push(`Key architectural rules: ${architecture.invariants.slice(0, 2).join(', ')}`);
+        }
+        const summary = parts.join('. ') + '.';
+        return {
+            techStack,
+            architecture,
+            summary,
+        };
+    }
+}
+exports.ProjectKnowledgeService = ProjectKnowledgeService;
+//# sourceMappingURL=project-knowledge-service.js.map