@thelogicatelier/sylva 1.0.4 → 1.0.10

package/dist/awareness/manifestScanner.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Full-repo manifest scanner.
+ * Recursively walks the entire repository to discover framework manifest files,
+ * regardless of nesting depth. Handles monorepos and nested subprojects.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanManifests = scanManifests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Directories to skip during scanning */
+const SCAN_IGNORE_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "__pycache__",
+    "venv",
+    ".venv",
+    "env",
+    ".env",
+    "dist",
+    "build",
+    "target",
+    "vendor",
+    "bin",
+    "obj",
+    "out",
+    "coverage",
+    "logs",
+    "tmp",
+    "temp",
+    ".idea",
+    ".vscode",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".angular",
+    ".DS_Store",
+]);
+/** Exact filenames to match as manifests */
+const MANIFEST_EXACT_NAMES = new Set([
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "openclaw.json",
+    "angular.json",
+    "workspace.json",
+    "project.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "poetry.lock",
+    "Pipfile",
+    "Pipfile.lock",
+    "setup.cfg",
+    "setup.py",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle",
+    "settings.gradle.kts",
+    "gradle.properties",
+    "go.mod",
+    "go.sum",
+    "Cargo.toml",
+    "Cargo.lock",
+    "global.json",
+    "packages.lock.json",
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "Makefile",
+    ".gitlab-ci.yml",
+]);
+/** File extension patterns for manifests (e.g. *.csproj) */
+const MANIFEST_EXTENSION_PATTERNS = [".csproj", ".fsproj", ".vbproj"];
+/** Maximum file size in characters to read */
+const MAX_FILE_SIZE = 500_000;
+/**
+ * Check if a filename matches a known manifest pattern.
+ */
+function isManifestFile(filename) {
+    if (MANIFEST_EXACT_NAMES.has(filename))
+        return true;
+    for (const ext of MANIFEST_EXTENSION_PATTERNS) {
+        if (filename.endsWith(ext))
+            return true;
+    }
+    return false;
+}
+/**
+ * Recursively scan a repository for manifest files.
+ * Returns all discovered manifest files with metadata.
+ */
+function scanManifests(repoPath) {
+    const results = [];
+    const absoluteRoot = path.resolve(repoPath);
+    function walk(dir, depth) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch (error) {
+            // Permission denied, broken symlink, or other OS-level issue
+            console.warn(`⚠️  Skipping unreadable directory: ${path.relative(absoluteRoot, dir) || "."}\n` +
+                `   Reason: ${error.message}\n` +
+                `   Manifests inside this directory will not be discovered.`);
+            return;
+        }
+        for (const entry of entries) {
+            // Skip ignored directories and hidden dirs (except specific manifest patterns)
+            if (SCAN_IGNORE_DIRS.has(entry))
+                continue;
+            const fullPath = path.join(dir, entry);
+            let stat;
+            try {
+                stat = fs.statSync(fullPath);
+            }
+            catch {
+                // Broken symlink or permission issue — skip silently (individual files are not noteworthy)
+                continue;
+            }
+            if (stat.isDirectory()) {
+                // Skip hidden directories (starting with .) except the repo root
+                if (entry.startsWith(".") && depth > 0)
+                    continue;
+                walk(fullPath, depth + 1);
+            }
+            else if (stat.isFile()) {
+                if (isManifestFile(entry) && stat.size <= MAX_FILE_SIZE) {
+                    results.push({
+                        absolutePath: fullPath,
+                        relativePath: path.relative(absoluteRoot, fullPath),
+                        filename: entry,
+                        depth,
+                        size: stat.size,
+                    });
+                }
+            }
+        }
+    }
+    walk(absoluteRoot, 0);
+    // Sort by depth (shallow first) then alphabetically for deterministic order
+    results.sort((a, b) => {
+        if (a.depth !== b.depth)
+            return a.depth - b.depth;
+        return a.relativePath.localeCompare(b.relativePath);
+    });
+    return results;
+}

package/dist/awareness/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared types for the Sylva awareness system.
+ * These types are used across manifest scanning, parsing, detection, and web grounding.
+ */
+/** Version certainty levels — NEVER ASSUME */
+export type VersionCertainty = "exact" | "unknown" | "ambiguous";
+/** Version information extracted from a manifest file */
+export interface VersionInfo {
+    value?: string;
+    certainty: VersionCertainty;
+    sourceFile?: string;
+    sourcePath?: string;
+    notes?: string;
+}
+/** Signal kinds emitted by manifest parsers */
+export type SignalKind = "framework" | "version" | "orchestrator" | "entrypoint" | "tooling";
+/** Evidence for a detected signal */
+export interface SignalEvidence {
+    file: string;
+    reason: string;
+    excerpt?: string;
+}
+/** Scope of a signal — which subproject it belongs to */
+export interface SignalScope {
+    pathRoot?: string;
+}
+/** A single signal emitted by a manifest parser */
+export interface Signal {
+    kind: SignalKind;
+    frameworkId: string;
+    frameworkName: string;
+    version?: VersionInfo;
+    evidence: SignalEvidence;
+    scope: SignalScope;
+}
+/** A discovered manifest file */
+export interface ManifestFile {
+    absolutePath: string;
+    relativePath: string;
+    filename: string;
+    depth: number;
+    size: number;
+}
+/** A detected stack with confidence and evidence */
+export interface StackInfo {
+    frameworkId: string;
+    frameworkName: string;
+    confidence: number;
+    versions: VersionInfo[];
+    evidence: Signal[];
+    rootPath?: string;
+}
+/** A workload in the architecture model */
+export interface Workload {
+    id: string;
+    name: string;
+    rootPath: string;
+    frameworks: string[];
+    entrypoints: string[];
+    buildTools: string[];
+    evidence: SignalEvidence[];
+}
+/** Orchestrator info (e.g., OpenClaw) */
+export interface OrchestratorInfo {
+    id: string;
+    configPath: string;
+    details: Record<string, unknown>;
+}
+/** Architecture model derived from detection */
+export interface ArchitectureModel {
+    primaryOrchestrator?: OrchestratorInfo;
+    workloads: Workload[];
+    repoType: "single" | "monorepo" | "unknown";
+    navigation: {
+        whatToReadFirst: string[];
+        whereThingsLive: string[];
+    };
+}
+/** Reference mode for web grounding */
+export type ReferenceMode = "versioned" | "latest_fallback";
+/** A single web search result */
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+/** Grouped web references for a framework */
+export interface WebReference {
+    frameworkId: string;
+    frameworkName: string;
+    versionInfo: VersionInfo;
+    referenceMode: ReferenceMode;
+    results: WebSearchResult[];
+}
+/** The complete output of the awareness pipeline */
+export interface AwarenessResult {
+    manifests: ManifestFile[];
+    signals: Signal[];
+    stacks: StackInfo[];
+    architecture: ArchitectureModel;
+    webReferences: WebReference[];
+    constraintsBlock: string;
+    awarenessContext: string;
+    errors: string[];
+}

package/dist/awareness/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Shared types for the Sylva awareness system.
+ * These types are used across manifest scanning, parsing, detection, and web grounding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/awareness/versionResolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Version resolver.
+ * Consolidates version signals per framework and determines version certainty.
+ * Core rule: NEVER ASSUME versions.
+ */
+import { Signal, VersionInfo } from "./types";
+/**
+ * Resolve the best version info for a given framework from its signals.
+ * Prioritizes exact > ambiguous > unknown.
+ * If multiple exact versions exist for different source files, picks the shallowest one.
+ */
+export declare function resolveVersion(signals: Signal[]): VersionInfo;
+/**
+ * Resolve versions for all detected frameworks.
+ * Groups signals by frameworkId and resolves each.
+ */
+export declare function resolveAllVersions(signals: Signal[]): Map<string, VersionInfo>;

package/dist/awareness/versionResolver.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Version resolver.
+ * Consolidates version signals per framework and determines version certainty.
+ * Core rule: NEVER ASSUME versions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersion = resolveVersion;
+exports.resolveAllVersions = resolveAllVersions;
+/**
+ * Resolve the best version info for a given framework from its signals.
+ * Prioritizes exact > ambiguous > unknown.
+ * If multiple exact versions exist for different source files, picks the shallowest one.
+ */
+function resolveVersion(signals) {
+    const versionSignals = signals.filter((s) => s.version);
+    if (versionSignals.length === 0) {
+        return { certainty: "unknown", notes: "No version information found" };
+    }
+    // Separate by certainty
+    const exact = versionSignals.filter((s) => s.version.certainty === "exact");
+    const ambiguous = versionSignals.filter((s) => s.version.certainty === "ambiguous");
+    if (exact.length === 1) {
+        return exact[0].version;
+    }
+    if (exact.length > 1) {
+        // Multiple exact versions — check if they agree
+        const uniqueValues = [...new Set(exact.map((s) => s.version.value))];
+        if (uniqueValues.length === 1) {
+            return exact[0].version;
+        }
+        // Conflicting exact versions — mark ambiguous
+        return {
+            value: uniqueValues[0],
+            certainty: "ambiguous",
+            sourceFile: exact[0].version.sourceFile,
+            notes: `Multiple exact versions found: ${uniqueValues.join(", ")}`,
+        };
+    }
+    if (ambiguous.length > 0) {
+        return ambiguous[0].version;
+    }
+    return { certainty: "unknown", notes: "No resolvable version" };
+}
+/**
+ * Resolve versions for all detected frameworks.
+ * Groups signals by frameworkId and resolves each.
+ */
+function resolveAllVersions(signals) {
+    const grouped = new Map();
+    for (const signal of signals) {
+        if (!grouped.has(signal.frameworkId)) {
+            grouped.set(signal.frameworkId, []);
+        }
+        grouped.get(signal.frameworkId).push(signal);
+    }
+    const resolved = new Map();
+    for (const [frameworkId, frameworkSignals] of grouped) {
+        resolved.set(frameworkId, resolveVersion(frameworkSignals));
+    }
+    return resolved;
+}

package/dist/awareness/webGrounding.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Web grounding — version-aware query builder and reference gatherer.
+ * Uses Brave Search to fetch official docs for detected frameworks.
+ * NEVER ASSUMES — queries are version-specific only when exact version is known.
+ */
+import { StackInfo, VersionInfo, WebReference } from "./types";
+/**
+ * Build search queries for a framework based on version info.
+ */
+export declare function buildQueries(frameworkName: string, versionInfo: VersionInfo): string[];
+/**
+ * Gather web references for detected frameworks.
+ * @param stacks Detected stacks sorted by confidence
+ * @param limitPerFramework Max queries per framework
+ * @param cacheDir Optional cache directory
+ */
+export declare function gatherReferences(stacks: StackInfo[], limitPerFramework?: number, cacheDir?: string): Promise<{
+    references: WebReference[];
+    errors: string[];
+}>;

package/dist/awareness/webGrounding.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Web grounding — version-aware query builder and reference gatherer.
+ * Uses Brave Search to fetch official docs for detected frameworks.
+ * NEVER ASSUMES — queries are version-specific only when exact version is known.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQueries = buildQueries;
+exports.gatherReferences = gatherReferences;
+const braveSearch_1 = require("./braveSearch");
+const versionResolver_1 = require("./versionResolver");
+/**
+ * Build search queries for a framework based on version info.
+ */
+function buildQueries(frameworkName, versionInfo) {
+    const queries = [];
+    if (versionInfo.certainty === "exact" && versionInfo.value) {
+        // Extract major.minor from version
+        const parts = versionInfo.value.replace(/^v/, "").split(".");
+        const major = parts[0];
+        const minor = parts.length > 1 ? parts[1] : undefined;
+        const majorMinor = minor ? `${major}.${minor}` : major;
+        queries.push(`${frameworkName} ${major} documentation official`);
+        if (minor) {
+            queries.push(`${frameworkName} ${majorMinor} reference documentation`);
+        }
+        queries.push(`${frameworkName} ${major} best practices`);
+    }
+    else {
+        // Unknown or ambiguous — use latest docs
+        queries.push(`${frameworkName} official documentation`);
+        queries.push(`${frameworkName} best practices`);
+    }
+    return queries;
+}
+/**
+ * Gather web references for detected frameworks.
+ * @param stacks Detected stacks sorted by confidence
+ * @param limitPerFramework Max queries per framework
+ * @param cacheDir Optional cache directory
+ */
+async function gatherReferences(stacks, limitPerFramework = 3, cacheDir) {
+    const references = [];
+    const errors = [];
+    if (!(0, braveSearch_1.isBraveSearchAvailable)()) {
+        errors.push("BRAVE_API_KEY not set — web grounding is disabled.\n" +
+            "   → Framework detection and version resolution still work perfectly.\n" +
+            "   → To enable web-grounded documentation references, set BRAVE_API_KEY in your .env file.\n" +
+            "   → Get a free API key at: https://brave.com/search/api/");
+        return { references, errors };
+    }
+    // Pick top frameworks by confidence (skip generic ones like "nodejs", "python")
+    const GENERIC_IDS = new Set([
+        "nodejs",
+        "python",
+        "java-maven",
+        "java-gradle",
+        "dotnet",
+        "docker",
+    ]);
+    const targetStacks = stacks
+        .filter((s) => !GENERIC_IDS.has(s.frameworkId) && s.confidence >= 60)
+        .slice(0, 6);
+    // Always include orchestrators
+    const orchestratorStacks = stacks.filter((s) => s.evidence.some((e) => e.kind === "orchestrator"));
+    for (const orc of orchestratorStacks) {
+        if (!targetStacks.some((t) => t.frameworkId === orc.frameworkId)) {
+            targetStacks.push(orc);
+        }
+    }
+    for (const stack of targetStacks) {
+        const versionInfo = (0, versionResolver_1.resolveVersion)(stack.evidence);
+        const queries = buildQueries(stack.frameworkName, versionInfo);
+        const referenceMode = versionInfo.certainty === "exact" ? "versioned" : "latest_fallback";
+        const allResults = [];
+        for (const query of queries.slice(0, limitPerFramework)) {
+            try {
+                const results = await (0, braveSearch_1.braveSearch)(query, { cacheDir });
+                allResults.push(...results);
+            }
+            catch (error) {
+                errors.push(`Web search failed for "${query}": ${error.message}`);
+            }
+        }
+        // Dedupe by URL
+        const seen = new Set();
+        const deduped = allResults.filter((r) => {
+            if (seen.has(r.url))
+                return false;
+            seen.add(r.url);
+            return true;
+        });
+        references.push({
+            frameworkId: stack.frameworkId,
+            frameworkName: stack.frameworkName,
+            versionInfo,
+            referenceMode: referenceMode,
+            results: deduped.slice(0, 5),
+        });
+    }
+    return { references, errors };
+}

package/dist/cli.js

@@ -43,6 +43,7 @@ const readline = __importStar(require("readline/promises"));
 const modelConfig_1 = require("./modelConfig");
 const utils_1 = require("./utils");
 const modules_1 = require("./modules");
+const awareness_1 = require("./awareness");
 function initEnvironment() {
     const envPath = path.resolve(process.cwd(), ".env");
     if (fs.existsSync(envPath)) {
@@ -97,23 +98,32 @@ async function runPipeline(repoDir, repoName, llmPrimary, llmMini, maxIterations
     const sourceTree = (0, utils_1.loadSourceTree)(repoDir);
     const numFiles = Object.keys(sourceTree).length;
     if (numFiles === 0) {
-        console.warn("\n⚠️  Warning: The loaded source tree is empty! Check IGNORED_DIRS or ensure the repository contains supported source files.");
+        console.warn("\n⚠️  The loaded source tree is empty — no supported files found.\n" +
+            "   Possible causes:\n" +
+            "   • The repository directory doesn't exist or is empty\n" +
+            "   • All files are filtered by IGNORED_DIRS (node_modules, dist, etc.)\n" +
+            "   • No files match ALLOWED_EXTENSIONS (.ts, .py, .java, .go, etc.)\n" +
+            "   Run with --help to check your --local-repository or --github-repository path.");
     }
     else {
         console.log(`✅ Extracted representation for ${numFiles} top-level file(s)/directory(ies).`);
     }
+    // Run Framework Awareness (deterministic, before LLM)
+    const awarenessResult = await (0, awareness_1.runAwareness)(repoDir, repoName);
+    const awarenessContext = awarenessResult.awarenessContext;
     const extractor = new modules_1.CodebaseConventionExtractor(maxIterations);
-    const extractResult = await extractor.extract(sourceTree);
+    const extractResult = await extractor.extract(sourceTree, awarenessContext);
     // Use the PRIMARY model for RLM analysis (needs strong reasoning to avoid hallucination)
     console.log(`=> Running the Codebase Analyzer RLM workflow...`);
     const rlmResult = await extractResult.analyzer.forward(llmPrimary, {
         sourceContext: extractResult.contextString,
+        awarenessContext,
     });
     // Use the PRIMARY model for compiling conventions (needs to accurately synthesize)
     const conventionsMarkdown = await extractor.compileMarkdown(llmPrimary, rlmResult);
     // Use MINI model for section extraction (cheaper, deterministic task)
     const creator = new modules_1.AgentsMdCreator();
-    const sections = await creator.extractAndCompileSections(llmMini, conventionsMarkdown, repoName);
+    const sections = await creator.extractAndCompileSections(llmMini, conventionsMarkdown, repoName, awarenessContext);
     const finalAgentsMd = (0, utils_1.compileAgentsMd)(sections, repoName);
     (0, utils_1.saveAgentsToDisk)(repoName, finalAgentsMd);
     console.log("\n======================================================");
@@ -166,7 +176,12 @@ async function main() {
             process.exit(0);
         }
         catch (err) {
-            console.error(`\n❌ Error occurred: ${err.message}`);
+            console.error(`\n❌ Pipeline failed: ${err.message}\n` +
+                `   If this is an API error, check that your API key is valid and has sufficient quota.\n` +
+                `   If this is unexpected, report it at: https://github.com/achatt89/sylva/issues`);
+            if (err.stack) {
+                console.error(`\n   Stack trace:\n   ${err.stack.split("\n").slice(1, 5).join("\n   ")}`);
+            }
             process.exit(1);
         }
     });

package/dist/constants.js

@@ -75,6 +75,11 @@ exports.ALLOWED_EXTENSIONS = new Set([
     ".r",
     ".m",
     ".pl",
+    ".lock",
+    ".cfg",
+    ".csproj",
+    ".fsproj",
+    ".gradle",
 ]);
 exports.IGNORED_DIRS = new Set([
     "node_modules",
@@ -119,4 +124,10 @@ exports.DEPENDENCY_MANIFESTS = new Set([
     "docker-compose.yml",
     "docker-compose.yaml",
     "package.json",
+    "openclaw.json",
+    "angular.json",
+    "workspace.json",
+    "global.json",
+    "Cargo.lock",
+    "go.mod",
 ]);

package/dist/modules.d.ts

@@ -1,12 +1,15 @@
 import { AgentsMdSections, TreeType } from "./utils";
 export declare class CodebaseConventionExtractor {
     private maxIterations;
+    private awarenessContext?;
     constructor(maxIterations?: number);
     extract(sourceTree: {
         [key: string]: TreeType;
-    }): Promise<{
+    }, awarenessContext?: string): Promise<{
         analyzer: import("@ax-llm/ax").AxAgent<{
             readonly sourceContext: string;
+        } & {
+            readonly awarenessContext: string;
         }, {
             readonly projectOverview: string;
         } & {
@@ -49,5 +52,5 @@ export declare class CodebaseConventionExtractor {
     compileMarkdown(llm: any, extractResult: any): Promise<string>;
 }
 export declare class AgentsMdCreator {
-    extractAndCompileSections(llm: any, conventionsMarkdown: string, repositoryName: string): Promise<AgentsMdSections>;
+    extractAndCompileSections(llm: any, conventionsMarkdown: string, repositoryName: string, awarenessContext?: string): Promise<AgentsMdSections>;
 }

package/dist/modules.js

@@ -20,12 +20,19 @@ function serializeSourceTree(tree, indent = "") {
 }
 class CodebaseConventionExtractor {
     maxIterations;
+    awarenessContext;
     constructor(maxIterations = 35) {
         this.maxIterations = maxIterations;
     }
-    async extract(sourceTree) {
+    async extract(sourceTree, awarenessContext) {
         console.log("=> Preparing and serializing Source Tree for RLM analysis...");
-        const contextString = serializeSourceTree(sourceTree);
+        let contextString = serializeSourceTree(sourceTree);
+        // Store awareness context for use in subsequent pipeline steps
+        this.awarenessContext = awarenessContext;
+        // Prepend awareness context if available
+        if (awarenessContext) {
+            contextString = `${awarenessContext}\n\n---\n\nSOURCE TREE:\n${contextString}`;
+        }
         console.log(`=> Running AxAgent (RLM) for Codebase Analysis on ${Object.keys(sourceTree).length} root modules...`);
         // Use the f() builder for reliable type definition instead of long strings
         const agentSig = prompts_1.CODEBASE_ANALYSIS_SIGNATURE;
@@ -48,13 +55,18 @@ class CodebaseConventionExtractor {
         // Equivalent to dspy.ChainOfThought(CompileConventionsMarkdown)
         const compileSig = prompts_1.COMPILE_CONVENTIONS_SIGNATURE;
         const compiler = (0, ax_1.ax)(compileSig);
-        const finalResult = await compiler.forward(llm, extractResult);
+        // Inject awarenessContext into the compilation step so constraints flow through
+        const inputWithAwareness = {
+            ...extractResult,
+            awarenessContext: this.awarenessContext || "No framework awareness context available.",
+        };
+        const finalResult = await compiler.forward(llm, inputWithAwareness);
         return finalResult.markdownDocument;
     }
 }
 exports.CodebaseConventionExtractor = CodebaseConventionExtractor;
 class AgentsMdCreator {
-    async extractAndCompileSections(llm, conventionsMarkdown, repositoryName) {
+    async extractAndCompileSections(llm, conventionsMarkdown, repositoryName, awarenessContext) {
         console.log(`=> Extracting individual AGENTS.md sections for repository: ${repositoryName}...`);
         // Equivalent to ExtractAgentsSections via ChainOfThought
         const sectionSig = prompts_1.EXTRACT_AGENTS_SECTIONS_SIGNATURE;
@@ -62,6 +74,7 @@ class AgentsMdCreator {
         const sections = await sectionExtractor.forward(llm, {
             conventionsMarkdown,
             repositoryName,
+            awarenessContext: awarenessContext || "No framework awareness context available.",
         });
         return sections;
     }

package/dist/prompts.d.ts

@@ -1,5 +1,7 @@
 export declare const CODEBASE_ANALYSIS_SIGNATURE: import("@ax-llm/ax").AxSignature<{
     readonly sourceContext: string;
+} & {
+    readonly awarenessContext: string;
 }, {
     readonly projectOverview: string;
 } & {
@@ -77,6 +79,8 @@ export declare const COMPILE_CONVENTIONS_SIGNATURE: import("@ax-llm/ax").AxSigna
     readonly agentWorkflow: string;
 } & {
     readonly fewShotExamples: string;
+} & {
+    readonly awarenessContext: string;
 }, {
     readonly markdownDocument: string;
 }>;
@@ -84,6 +88,8 @@ export declare const EXTRACT_AGENTS_SECTIONS_SIGNATURE: import("@ax-llm/ax").AxS
     readonly conventionsMarkdown: string;
 } & {
     readonly repositoryName: string;
+} & {
+    readonly awarenessContext: string;
 }, {
     readonly projectOverview: string;
 } & {