devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/xml-naming/src/index.js

@@ -0,0 +1,270 @@
+/**
+ * xml-naming
+ * Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.
+ * Covers: Name, NCName, QName, NMToken, NMTokens
+ *
+ * XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name
+ * XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar
+ * XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName
+ */
+
+// ---------------------------------------------------------------------------
+// Character class strings — XML 1.0
+//
+// NameStartChar ::= ":" | [A-Z] | "_" | [a-z]
+//   | [#xC0-#xD6]   | [#xD8-#xF6]   | [#xF8-#x2FF]
+//   | [#x370-#x37D] | [#x37F-#x1FFF]    <- split to exclude #x0487
+//   | [#x200C-#x200D]
+//   | [#x2070-#x218F] | [#x2C00-#x2FEF]
+//   | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]
+//
+// NameChar ::= NameStartChar | "-" | "." | [0-9]
+//   | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
+//
+// Note: \u0487 (Combining Cyrillic Millions Sign) was added in Unicode 4.0,
+// after XML 1.0 was defined against Unicode 2.0. It falls inside the range
+// \u037F-\u1FFF but must be excluded. We split that range into
+// \u037F-\u0486 and \u0488-\u1FFF to exclude it explicitly.
+// ---------------------------------------------------------------------------
+
+const nameStartChar10 =
+  ':A-Za-z_' +
+  '\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF' +
+  '\u0370-\u037D' +
+  '\u037F-\u0486\u0488-\u1FFF' +  // split to exclude \u0487
+  '\u200C-\u200D' +
+  '\u2070-\u218F' +
+  '\u2C00-\u2FEF' +
+  '\u3001-\uD7FF' +
+  '\uF900-\uFDCF' +
+  '\uFDF0-\uFFFD';
+
+const nameChar10 =
+  nameStartChar10 +
+  '\\-\\.\\d' +
+  '\u00B7' +
+  '\u0300-\u036F' +
+  '\u203F-\u2040';
+
+// ---------------------------------------------------------------------------
+// Character class strings — XML 1.1
+//
+// Differences from XML 1.0:
+//
+// NameStartChar:
+//   1.0 has split ranges: \u00C0-\u00D6, \u00D8-\u00F6, \u00F8-\u02FF
+//   1.1 merges them into: \u00C0-\u02FF
+//   (\u00D7 x and \u00F7 / are division symbols, excluded in both versions)
+//
+//   1.0 tops out at \uFFFD (BMP only)
+//   1.1 adds \u{10000}-\u{EFFFF} (supplementary planes)
+//   These require the /u flag on the RegExp — see buildRegexes below.
+//
+// NameChar:
+//   1.1 adds \u0487 (Combining Cyrillic Millions Sign, added in Unicode 4.0)
+// ---------------------------------------------------------------------------
+
+const nameStartChar11 =
+  ':A-Za-z_' +
+  '\u00C0-\u02FF' +                    // merged — 1.0 had three split ranges here
+  '\u0370-\u037D' +
+  '\u037F-\u0486\u0488-\u1FFF' +       // split to exclude \u0487 (combining mark, never a NameStartChar)
+  '\u200C-\u200D' +
+  '\u2070-\u218F' +
+  '\u2C00-\u2FEF' +
+  '\u3001-\uD7FF' +
+  '\uF900-\uFDCF' +
+  '\uFDF0-\uFFFD' +
+  '\u{10000}-\u{EFFFF}';     // supplementary planes — REQUIRES /u flag on RegExp
+
+const nameChar11 =
+  nameStartChar11 +
+  '\\-\\.\\d' +
+  '\u00B7' +
+  '\u0300-\u036F' +
+  '\u0487' +                 // Combining Cyrillic Millions Sign — valid in 1.1, not 1.0
+  '\u203F-\u2040';
+
+// ---------------------------------------------------------------------------
+// Regex builders
+//
+// XML 1.0 regexes: no flags — BMP only, standard JS regex behaviour.
+// XML 1.1 regexes: /u flag — required for \u{10000}-\u{EFFFF} to match actual
+//   supplementary code points rather than lone surrogates (which are illegal XML).
+// ---------------------------------------------------------------------------
+
+const buildRegexes = (startChar, char, flags = '') => {
+  const ncStart = startChar.replace(':', '');
+  const ncChar = char.replace(':', '');
+  const ncNamePat = `[${ncStart}][${ncChar}]*`;
+
+  return {
+    name: new RegExp(`^[${startChar}][${char}]*$`, flags),
+    ncName: new RegExp(`^${ncNamePat}$`, flags),
+    qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),
+    nmToken: new RegExp(`^[${char}]+$`, flags),
+    nmTokens: new RegExp(`^[${char}]+(?:\\s+[${char}]+)*$`, flags),
+  };
+};
+
+const regexes10 = buildRegexes(nameStartChar10, nameChar10);       // no /u — BMP only
+const regexes11 = buildRegexes(nameStartChar11, nameChar11, 'u');  // /u — enables \u{10000}-\u{EFFFF}
+
+const getRegexes = (xmlVersion = '1.0') =>
+  xmlVersion === '1.1' ? regexes11 : regexes10;
+
+// ---------------------------------------------------------------------------
+// Boolean validators
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if the string is a valid XML Name.
+ * Colons are allowed anywhere (Name production).
+ * Used for: DOCTYPE entity names, notation names, DTD element declarations.
+ */
+export const name = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).name.test(str);
+
+/**
+ * Returns true if the string is a valid NCName (Non-Colonized Name).
+ * Colons are not permitted.
+ * Used for: namespace prefixes, local names, SVG id attributes.
+ */
+export const ncName = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).ncName.test(str);
+
+/**
+ * Returns true if the string is a valid QName (Qualified Name).
+ * Allows exactly one colon as a prefix separator: prefix:localName.
+ * Used for: element and attribute names in namespace-aware XML/SVG.
+ */
+export const qName = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).qName.test(str);
+
+/**
+ * Returns true if the string is a valid NMToken.
+ * Like Name but no restriction on the first character.
+ * Used for: DTD NMTOKEN attribute values.
+ */
+export const nmToken = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).nmToken.test(str);
+
+/**
+ * Returns true if the string is a valid NMTokens value.
+ * A whitespace-separated list of NMToken values.
+ * Used for: DTD NMTOKENS attribute values.
+ */
+export const nmTokens = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).nmTokens.test(str);
+
+// ---------------------------------------------------------------------------
+// Diagnostic validator
+// ---------------------------------------------------------------------------
+
+const PRODUCTIONS = ['name', 'ncName', 'qName', 'nmToken', 'nmTokens'];
+
+/**
+ * Validates a string against a named production and returns a detailed result.
+ *
+ * @param {string} str
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]
+ * @returns {{ valid: boolean, production: string, input: string, reason?: string, position?: number }}
+ */
+export const validate = (str, production, { xmlVersion = '1.0' } = {}) => {
+  if (!PRODUCTIONS.includes(production)) {
+    throw new TypeError(
+      `Unknown production "${production}". Must be one of: ${PRODUCTIONS.join(', ')}`
+    );
+  }
+
+  const validators = { name, ncName, qName, nmToken, nmTokens };
+  const isValid = validators[production](str, { xmlVersion });
+
+  if (isValid) return { valid: true, production, input: str };
+
+  let reason = 'Does not match the production rules';
+  let position;
+
+  if (str.length === 0) {
+    reason = 'Input is empty';
+  } else if (production === 'ncName' && str.includes(':')) {
+    position = str.indexOf(':');
+    reason = 'Colon is not allowed in NCName';
+  } else if (production === 'qName' && str.startsWith(':')) {
+    reason = 'QName cannot start with a colon';
+    position = 0;
+  } else if (production === 'qName' && str.endsWith(':')) {
+    reason = 'QName cannot end with a colon';
+    position = str.length - 1;
+  } else if (production === 'qName' && (str.match(/:/g) || []).length > 1) {
+    reason = 'QName can have at most one colon';
+    position = str.lastIndexOf(':');
+  } else if (
+    ['name', 'ncName', 'qName'].includes(production) &&
+    !/^[:A-Za-z_\u00C0-\uFFFD]/.test(str[0])
+  ) {
+    reason = `First character "${str[0]}" is not a valid NameStartChar`;
+    position = 0;
+  } else {
+    for (let i = 0; i < str.length; i++) {
+      if (!/[\w\-\\.:\u00B7\u00C0-\uFFFD]/.test(str[i])) {
+        reason = `Character "${str[i]}" at position ${i} is not a valid NameChar`;
+        position = i;
+        break;
+      }
+    }
+  }
+
+  return { valid: false, production, input: str, reason, position };
+};
+
+// ---------------------------------------------------------------------------
+// Batch validator
+// ---------------------------------------------------------------------------
+
+/**
+ * Validates an array of strings against a named production.
+ *
+ * @param {string[]} strings
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]
+ * @returns {Array<{ valid: boolean, production: string, input: string, reason?: string, position?: number }>}
+ */
+export const validateAll = (strings, production, opts = {}) =>
+  strings.map(str => validate(str, production, opts));
+
+// ---------------------------------------------------------------------------
+// Sanitizer
+// ---------------------------------------------------------------------------
+
+/**
+ * Transforms an invalid string into the nearest valid XML name for the given production.
+ *
+ * @param {string} str
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ replacement?: string }} [opts]
+ * @returns {string}
+ */
+export const sanitize = (str, production = 'name', { replacement = '_' } = {}) => {
+  if (!str) return replacement;
+
+  let result = str;
+
+  // Strip colons for NCName
+  if (production === 'ncName') {
+    result = result.replace(/:/g, '');
+  }
+
+  // Replace illegal characters
+  result = result.replace(/[^\w\-\.:\u00B7\u00C0-\uFFFD]/g, replacement);
+
+  // Fix invalid start character for Name / NCName / QName
+  if (production !== 'nmToken' && production !== 'nmTokens') {
+    if (/^[\-\.\d]/.test(result)) {
+      result = replacement + result;
+    }
+  }
+
+  return result || replacement;
+};

package/dist/temp-prefix/node_modules/devbrain-cli/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "devbrain-cli",
+  "version": "0.3.0",
+  "description": "Offline-first CLI tool providing persistent, deterministic project memory for AI assistants.",
+  "keywords": [
+    "devbrain",
+    "cli",
+    "ai",
+    "context",
+    "memory",
+    "offline"
+  ],
+  "homepage": "https://github.com/CodeItAlone/devbrain#readme",
+  "bugs": {
+    "url": "https://github.com/CodeItAlone/devbrain/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeItAlone/devbrain.git"
+  },
+  "license": "MIT",
+  "author": "Subrato Kundu (https://github.com/CodeItAlone/devbrain)",
+  "type": "module",
+  "main": "./dist/bin.js",
+  "types": "./dist/bin.d.ts",
+  "bin": {
+    "devbrain": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/bin.js",
+      "types": "./dist/bin.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "compile": "tsc --build",
+    "prepack": "node ../../scripts/prepare-cli.js"
+  },
+  "dependencies": {
+    "@devbrain/core": "^0.3.0",
+    "@devbrain/shared": "^0.3.0",
+    "@huggingface/transformers": "^4.2.0",
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "fast-glob": "^3.3.2",
+    "fast-xml-parser": "^5.9.3",
+    "simple-git": "^3.23.0"
+  },
+  "bundleDependencies": [
+    "@devbrain/core",
+    "@devbrain/shared"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.d.ts

@@ -0,0 +1,24 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export interface SourceModule {
+    filePath: string;
+    name: string;
+    type: 'service' | 'controller' | 'route' | 'model' | 'other';
+    classes: string[];
+    functions: string[];
+    imports: string[];
+}
+export interface SourceApi {
+    method: string;
+    path: string;
+    file: string;
+}
+export declare class SourceCodeAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "source-code";
+    readonly name = "Source Code Structure Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.js

@@ -0,0 +1,126 @@
+import { join, extname, basename } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export class SourceCodeAnalyzer {
+    fsService;
+    id = 'source-code';
+    name = 'Source Code Structure Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        // Supports if there are any TS/JS source files in the project list
+        return project.files.some((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist'));
+    }
+    async analyze(project) {
+        const modules = [];
+        const apis = [];
+        const databaseEntities = new Set();
+        const authMethods = new Set();
+        const externalServices = new Set();
+        // Process only TS/JS source files up to a reasonable limit (e.g. 500 files for speed)
+        const sourceFiles = project.files
+            .filter((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist') && !f.endsWith('.test.ts') && !f.endsWith('.spec.ts'))
+            .slice(0, 500);
+        for (const file of sourceFiles) {
+            try {
+                const fullPath = join(project.cwd, file);
+                const content = await this.fsService.read(fullPath);
+                const baseName = basename(file);
+                const ext = extname(file);
+                const nameWithoutExt = baseName.slice(0, -ext.length);
+                // 1. Determine Module Type
+                let type = 'other';
+                if (/controller/i.test(nameWithoutExt))
+                    type = 'controller';
+                else if (/service/i.test(nameWithoutExt))
+                    type = 'service';
+                else if (/route/i.test(nameWithoutExt))
+                    type = 'route';
+                else if (/model/i.test(nameWithoutExt) || /entity/i.test(nameWithoutExt))
+                    type = 'model';
+                // 2. Classes
+                const classes = [];
+                const classRegex = /class\s+([A-Za-z0-9_]+)/g;
+                let match;
+                while ((match = classRegex.exec(content)) !== null) {
+                    classes.push(match[1]);
+                    if (type === 'model') {
+                        databaseEntities.add(match[1]);
+                    }
+                }
+                // 3. Functions
+                const functions = [];
+                const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_]+)/g;
+                while ((match = funcRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                const arrowFuncRegex = /(?:const|let|var)\s+([A-Za-z0-9_]+)\s*=\s*(?:async\s*)?\((?:[^)]*)\)\s*=>/g;
+                while ((match = arrowFuncRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                // 4. Imports / External Services
+                const imports = [];
+                const importRegex = /(?:import|require)\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const importSource = match[1];
+                    imports.push(importSource);
+                    // Detect external service integrations
+                    if (['axios', 'stripe', 'twilio', 'aws-sdk', 'redis', '@google-cloud/'].some(s => importSource.includes(s))) {
+                        externalServices.add(importSource);
+                    }
+                }
+                // 5. API Endpoints
+                // Match express-like router: router.get('/path', ...) or app.post('/path', ...)
+                const expressApiRegex = /(?:app|router|route|express)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/gi;
+                while ((match = expressApiRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2],
+                        file,
+                    });
+                }
+                // Match NestJS decorators: @Get('/path') or @Post()
+                const nestApiDecoratorRegex = /@(Get|Post|Put|Delete|Patch)\s*\(\s*(?:['"]([^'"]+)['"])?/g;
+                while ((match = nestApiDecoratorRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2] || '/',
+                        file,
+                    });
+                }
+                // 6. Authentication detection
+                if (/jwt|passport|bcrypt|oauth|session|authHeader|bearer/i.test(content)) {
+                    if (content.includes('jwt') || content.includes('JWT'))
+                        authMethods.add('JWT');
+                    if (content.includes('oauth') || content.includes('OAuth'))
+                        authMethods.add('OAuth');
+                    if (content.includes('session'))
+                        authMethods.add('Session-based');
+                }
+                modules.push({
+                    filePath: file,
+                    name: nameWithoutExt,
+                    type,
+                    classes,
+                    functions: functions.slice(0, 15), // cap function list
+                    imports,
+                });
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                modules,
+                apis: apis.slice(0, 100), // cap API endpoints
+                databaseEntities: Array.from(databaseEntities),
+                authMethods: Array.from(authMethods),
+                externalServices: Array.from(externalServices),
+            },
+        };
+    }
+}
+//# sourceMappingURL=source-code.analyzer.js.map

package/node_modules/@devbrain/core/dist/context/context.service.d.ts

@@ -1,17 +1,16 @@
+import { AggregatedAnalysis } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-/**
- * Service responsible for reading generated project memory and consolidating it into an optimized AI prompt context.
- */
 export declare class ContextService {
     private readonly fsService;
     constructor(fsService?: FilesystemService);
     /**
-     * Reads memory markdown files, validates existence, and compiles them into a single token-efficient string.
+     * Generates and writes context.md to the target directory.
      */
-    buildContext(memoryDir: string): Promise<string>;
+    generateContext(analysis: AggregatedAnalysis, memoryDir: string): Promise<string>;
     /**
-     * Formats and converts absolute top-level headers (#) to sub-headers (##)
-     * to maintain a single root h1 structure and optimizes whitespaces.
+     * Reads project memory and compiles it into a single token-efficient string.
      */
+    buildContext(memoryDir: string): Promise<string>;
+    private buildContextString;
     private normalizeHeadings;
 }

package/node_modules/@devbrain/core/dist/context/context.service.js

@@ -1,18 +1,48 @@
-import { join } from 'node:path';
+import { join, dirname, basename } from 'node:path';
+import { CONTEXT_FILE_NAME, MEMORY_FILE_NAME, ValidationError, } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-import { ValidationError } from '@devbrain/shared';
-/**
- * Service responsible for reading generated project memory and consolidating it into an optimized AI prompt context.
- */
 export class ContextService {
     fsService;
     constructor(fsService = new FilesystemService()) {
         this.fsService = fsService;
     }
     /**
-     * Reads memory markdown files, validates existence, and compiles them into a single token-efficient string.
+     * Generates and writes context.md to the target directory.
+     */
+    async generateContext(analysis, memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const contextPath = join(targetDir, CONTEXT_FILE_NAME);
+        const contextContent = this.buildContextString(analysis);
+        const fileContent = [
+            '<!-- ⚠️ THIS FILE IS AUTO-GENERATED BY DEVBRAIN. -->',
+            '<!-- DO NOT EDIT. YOUR CHANGES WILL BE OVERWRITTEN. -->',
+            '',
+            contextContent,
+        ].join('\n');
+        await this.fsService.writeAtomic(contextPath, fileContent);
+        return contextContent;
+    }
+    /**
+     * Reads project memory and compiles it into a single token-efficient string.
      */
     async buildContext(memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const jsonPath = join(targetDir, MEMORY_FILE_NAME);
+        // If memory.json exists, build context from it
+        if (await this.fsService.exists(jsonPath)) {
+            try {
+                const analysis = await this.fsService.readJson(jsonPath);
+                return this.buildContextString(analysis);
+            }
+            catch {
+                // Fall back to folder scanning if parsing fails
+            }
+        }
+        // Ensure memory folder exists if memory.json is not present (backward compatibility check)
+        if (!(await this.fsService.exists(memoryDir))) {
+            throw new ValidationError('Project memory directory not found.', `The directory ${memoryDir} does not exist.`, 'Run "devbrain learn" to scan the repository and populate the memory files first.');
+        }
+        // Fallback: Read individual .md files (v0.1 structure)
         const files = [
             'summary.md',
             'stack.md',
@@ -22,17 +52,13 @@ export class ContextService {
             'timeline.md',
         ];
         const parts = [];
-        // Ensure memory folder exists
-        if (!(await this.fsService.exists(memoryDir))) {
-            throw new ValidationError('Project memory directory not found.', `The directory ${memoryDir} does not exist.`, 'Run "devbrain learn" to scan the repository and populate the memory files first.');
-        }
         parts.push('<!-- START OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
         parts.push('# DEVBRAIN PROJECT CONTEXT INDEX');
         parts.push('');
         for (const file of files) {
             const filePath = join(memoryDir, file);
             if (!(await this.fsService.exists(filePath))) {
-                continue; // Skip missing files gracefully or use a warning comment
+                continue;
             }
             const content = await this.fsService.read(filePath);
             const formatted = this.normalizeHeadings(file, content);
@@ -42,17 +68,77 @@ export class ContextService {
         parts.push('<!-- END OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
         return parts.join('\n');
     }
-    /**
-     * Formats and converts absolute top-level headers (#) to sub-headers (##)
-     * to maintain a single root h1 structure and optimizes whitespaces.
-     */
+    buildContextString(analysis) {
+        const readmeData = analysis.analyzers.readme || {};
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const tsconfigData = analysis.analyzers.tsconfig || {};
+        const gitData = analysis.analyzers.git || {};
+        const sourceCodeData = analysis.analyzers['source-code'] || {};
+        const projectName = analysis.projectName || packageJsonData.name || 'unnamed-project';
+        const overview = readmeData.description || 'No description available.';
+        const filesCount = analysis.files.length;
+        const keyFiles = analysis.files.filter((f) => f.includes('package.json') ||
+            f.includes('tsconfig.json') ||
+            f.includes('routes') ||
+            f.includes('controller') ||
+            f.includes('service') ||
+            f.includes('model') ||
+            f.includes('entity')).slice(0, 30);
+        const modules = (sourceCodeData.modules || [])
+            .map((m) => `- Module: \`${m.name}\` (Type: ${m.type}, File: \`${m.filePath}\`)\n  Classes: [${m.classes.join(', ')}]\n  Functions: [${m.functions.join(', ')}]`)
+            .join('\n');
+        const apis = (sourceCodeData.apis || [])
+            .map((a) => `- ${a.method} ${a.path}`)
+            .join('\n');
+        const dbs = (sourceCodeData.databaseEntities || []).map((d) => `- Model: ${d}`).join('\n');
+        const auths = (sourceCodeData.authMethods || []).map((a) => `- Auth: ${a}`).join('\n');
+        const externals = (sourceCodeData.externalServices || []).map((e) => `- Service: ${e}`).join('\n');
+        const commits = (gitData.recentCommits || [])
+            .slice(0, 3)
+            .map((c) => `- [${c.hash}] ${c.message}`)
+            .join('\n');
+        return [
+            '# DEVBRAIN AI CONTEXT',
+            '',
+            `## Project: ${projectName}`,
+            overview,
+            '',
+            `## Tech Stack & Language`,
+            `- Core Languages: ${analysis.technologies.join(', ') || 'None detected'}`,
+            `- Frameworks: ${analysis.frameworks.join(', ') || 'None detected'}`,
+            `- TS Compiler Target: ${tsconfigData.target || 'N/A'}`,
+            `- Strict Mode: ${tsconfigData.strict ? 'Enabled' : 'Disabled'}`,
+            '',
+            '## Project Architecture & Modules',
+            modules || '- No specific source code modules identified.',
+            '',
+            '## API Endpoints',
+            apis || '- No routes detected.',
+            '',
+            '## Database & Schemas',
+            dbs || '- No database models identified.',
+            '',
+            '## Authentication Systems',
+            auths || '- Default token/credentials handling.',
+            '',
+            '## Third-Party Integrations',
+            externals || '- No external API integrations.',
+            '',
+            `## Repository Structure (${filesCount} total files)`,
+            'Important files:',
+            keyFiles.map((kf) => `- \`${kf}\``).join('\n') || '- No critical files highlighted.',
+            '',
+            '## Recent Changes',
+            commits || '- No git commit log available.',
+            '',
+        ].join('\n');
+    }
     normalizeHeadings(fileName, content) {
         const sectionName = fileName.replace('.md', '').toUpperCase();
         const lines = content.split('\n');
         const processedLines = [`## SECTION: ${sectionName}`, ''];
         for (let line of lines) {
             line = line.trimEnd();
-            // Translate root header # to second-level ##
             if (line.startsWith('# ')) {
                 processedLines.push(`### ${line.substring(2)}`);
             }

package/node_modules/@devbrain/core/dist/embeddings/EmbeddingProvider.d.ts

@@ -0,0 +1,4 @@
+export interface EmbeddingProvider {
+    generateEmbedding(text: string): Promise<number[]>;
+    generateEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/node_modules/@devbrain/core/dist/embeddings/EmbeddingProvider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EmbeddingProvider.js.map