@thelogicatelier/sylva 1.0.4

package/README.md

@@ -0,0 +1,110 @@
+# Sylva 🌲
+
+Sylva is an automated AI tool to auto-generate comprehensive `AGENTS.md` and `CODEBASE_CONVENTIONS.md` documentation by reading your entire repository recursively using **Ax-LLM**.
+
+It extracts the folder structures, code conventions, state management patterns, and specific architecture styles embedded in your code directly into a format that future AI Coding Assistants (or human engineers) can perfectly follow.
+
+📖 **[Full Documentation](https://achatt89.github.io/sylva/)**
+
+### Features
+- Support for OpenAI, Google Gemini, Anthropic, and Azure LLMs.
+- Direct `--github-repository` fetching using Git Clone.
+- Direct `--local-repository` analysis.
+- Multi-LLM model configuration with automatic mini-model fallback for Codebase Analysis Iterations.
+- Strict Type-Safety achieved with Ax-LLM's internal framework tools.
+
+### Setup
+Install dependencies:
+```bash
+npm install
+```
+
+Configure your environment variables:
+```bash
+cp .env-example .env
+# Edit .env and supply your API Keys (GEMINI_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY, etc)
+```
+
+Build the project:
+```bash
+npm run build
+```
+
+### Execution
+
+The project is published to the NPM registry and can be executed natively anywhere!
+
+**Option 1: Run seamlessly without installing**
+```bash
+# Analyze the current working directory natively
+npx @thelogicatelier/sylva
+
+# Provide a specific GitHub repo
+npx @thelogicatelier/sylva --github-repository https://github.com/expressjs/express
+```
+
+**Option 2: Install globally on your system**
+```bash
+npm install -g @thelogicatelier/sylva
+
+# Once installed globally, you can execute it anywhere!
+sylva
+sylva --help
+```
+
+Alternatively, if running from source:
+```bash
+npm start -- --github-repository https://github.com/expressjs/express -m openai/gpt-4o
+```
+
+**List Supported Models:**
+```bash
+npx @thelogicatelier/sylva --list-models
+```
+
+### Advanced Usage: Tuning for Your Project
+
+The iteration count (`-i`) and model choice (`-m`) dramatically affect output accuracy. Here's a battle-tested guide:
+
+| Project Type | Example | Command | Rationale |
+|---|---|---|---|
+| **Small library** (<20 files) | `pallets/click` | `npx @thelogicatelier/sylva -m openai/gpt-4o -i 1` | Entire codebase fits in one context pass |
+| **Medium app** (20-100 files) | `expressjs/express` | `npx @thelogicatelier/sylva -m openai/gpt-4o -i 5` | Needs ~5 passes to traverse nested modules |
+| **Large monorepo** (multi-stack) | React + FastAPI + APIs | `npx @thelogicatelier/sylva -m openai/gpt-5.2 -i 25` | Deep traversal of cross-stack dependencies |
+| **Enterprise codebase** (500+ files) | Microservices | `npx @thelogicatelier/sylva -m anthropic/claude-sonnet-4.6 -i 35` | Maximum depth for service-oriented architectures |
+
+**Real-world example:** Analyzing a React/Tailwind frontend + Python/FastAPI backend + Wix API monorepo:
+```bash
+npx @thelogicatelier/sylva --local-repository . -m openai/gpt-5.2 -i 25
+```
+
+For detailed guidance, see the [Choosing the Right Model](https://achatt89.github.io/sylva/models/choosing.html) and [Iteration Depth Guide](https://achatt89.github.io/sylva/models/iterations.html) docs.
+
+### Environment Overrides
+- `AUTOSKILL_MODEL`: Set this to `gemini` or `anthropic` or `openai` to change the default execution provider globally without providing `-m` on every execution.
+- `GITHUB_REPO_URL`: Hardcode a repository for the CLI parser to utilize if no explicit configuration flags are provided.
+
+### Test Structure
+Unit tests are located at `tests/` which mirror the `/src` folder structure separating logical test groupings.
+Execute tests by running:
+```bash
+npm test
+```
+
+## Contributing
+
+We strictly follow a feature-branch workflow. Please ensure your contributions maintain high code quality and test coverage.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`) - *Our Husky pre-commit hooks will automatically lint and test your code.*
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## Issues, Bugs, and Feature Requests
+
+Please report all issues and feature requests using our [GitHub Issues](https://github.com/achatt89/sylva/issues) tracker. When reporting bugs, please provide a minimally reproducible example along with the console output (if applicable).
+
+---
+
+Built by [The Logic Atelier](https://thelogicatelier.com)

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export declare function resolveRepositoryTarget(args: any): Promise<{
+    repoUrl: string | null;
+    localPath: string | null;
+    repoName: string;
+}>;

package/dist/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+"use strict";
+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.resolveRepositoryTarget = resolveRepositoryTarget;
+const commander_1 = require("commander");
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline/promises"));
+const modelConfig_1 = require("./modelConfig");
+const utils_1 = require("./utils");
+const modules_1 = require("./modules");
+function initEnvironment() {
+    const envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+        dotenv.config({ path: envPath, override: true });
+    }
+}
+async function resolveRepositoryTarget(args) {
+    let githubRepo = args.githubRepository;
+    let localRepo = args.localRepository;
+    if (!githubRepo && !localRepo && args.repo) {
+        if (args.repo.startsWith("http") || args.repo.startsWith("git@")) {
+            githubRepo = args.repo;
+        }
+        else {
+            localRepo = args.repo;
+        }
+    }
+    if (!githubRepo && !localRepo) {
+        const githubEnv = process.env.GITHUB_REPO_URL;
+        if (githubEnv) {
+            githubRepo = githubEnv;
+        }
+        else {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await rl.question("Enter absolute path to local repository (or press Enter for current directory): ");
+            rl.close();
+            localRepo = answer.trim() ? answer.trim() : process.cwd();
+        }
+    }
+    if (githubRepo) {
+        const repoUrl = githubRepo.trim();
+        let repoName = repoUrl.replace(/\/$/, "").split("/").pop() || "unknown-repo";
+        if (repoName.endsWith(".git"))
+            repoName = repoName.slice(0, -4);
+        return { repoUrl, localPath: null, repoName };
+    }
+    else {
+        const localPath = path.resolve(localRepo);
+        if (!fs.existsSync(localPath))
+            throw new Error(`Local repository path does not exist: ${localPath}`);
+        const repoName = path.basename(localPath);
+        return { repoUrl: null, localPath, repoName };
+    }
+}
+async function runPipeline(repoDir, repoName, llmPrimary, llmMini, maxIterations) {
+    console.log(`\n======================================================`);
+    console.log(`🕵️‍♂️    SYLVA / AGENTS.md Generator Pipeline`);
+    console.log(`======================================================\n`);
+    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.");
+    }
+    else {
+        console.log(`✅ Extracted representation for ${numFiles} top-level file(s)/directory(ies).`);
+    }
+    const extractor = new modules_1.CodebaseConventionExtractor(maxIterations);
+    const extractResult = await extractor.extract(sourceTree);
+    // 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,
+    });
+    // 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 finalAgentsMd = (0, utils_1.compileAgentsMd)(sections, repoName);
+    (0, utils_1.saveAgentsToDisk)(repoName, finalAgentsMd);
+    console.log("\n======================================================");
+    console.log("🎉  AGENTS.md Generation Complete!");
+    console.log("======================================================\n");
+}
+async function main() {
+    initEnvironment();
+    const program = new commander_1.Command();
+    program
+        .name("sylva")
+        .description("Auto-generate AGENTS.md for your repository using Ax-LLM")
+        .version("1.0.0")
+        .argument("[repo]", "Absolute path to a local repository to analyze (default)")
+        .option("--github-repository <url>", "Public GitHub repository URL to analyze")
+        .option("--local-repository <path>", "Absolute path to a local repository to analyze")
+        .option("-m, --model <model>", "The LLM model to use (PROVIDER/MODEL)")
+        .option("--list-models", "List all supported models and exit")
+        .option("-i, --max-iterations <number>", "Max RLM iterations", "35")
+        .action(async (repo, options) => {
+        if (options.listModels) {
+            console.log((0, modelConfig_1.listSupportedModels)());
+            process.exit(0);
+        }
+        const parsedArgs = {
+            repo: repo,
+            githubRepository: options.githubRepository,
+            localRepository: options.localRepository,
+            model: options.model,
+            maxIterations: parseInt(options.maxIterations, 10),
+        };
+        try {
+            const { repoUrl, localPath, repoName } = await resolveRepositoryTarget(parsedArgs);
+            const modelConfig = (0, modelConfig_1.resolveModelConfig)(parsedArgs.model);
+            console.log(`Using provider: ${modelConfig.provider} | Primary: ${modelConfig.model} | Mini: ${modelConfig.model_mini}`);
+            const llmPrimary = (0, modelConfig_1.getLanguageModelService)(modelConfig, false);
+            const llmMini = (0, modelConfig_1.getLanguageModelService)(modelConfig, true);
+            let targetDir = localPath;
+            if (repoUrl) {
+                targetDir = fs.mkdtempSync(path.join(process.cwd(), `sylva-tmp-${repoName}-`));
+                (0, utils_1.cloneRepo)(repoUrl, targetDir);
+            }
+            if (!targetDir)
+                throw new Error("Could not resolve target directory");
+            await runPipeline(targetDir, repoName, llmPrimary, llmMini, parsedArgs.maxIterations);
+            if (repoUrl && targetDir) {
+                console.log(`Cleaning up temporary repository dir: ${targetDir}`);
+                fs.rmSync(targetDir, { recursive: true, force: true });
+            }
+            process.exit(0);
+        }
+        catch (err) {
+            console.error(`\n❌ Error occurred: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    await program.parseAsync(process.argv);
+}
+if (require.main === module) {
+    main();
+}

package/dist/constants.d.ts

@@ -0,0 +1,18 @@
+export interface ModelMetadata {
+    provider: string;
+    tier: "primary" | "mini";
+}
+export declare const PROVIDER_GEMINI = "gemini";
+export declare const PROVIDER_ANTHROPIC = "anthropic";
+export declare const PROVIDER_OPENAI = "openai";
+export declare const MODEL_CATALOG: Record<string, ModelMetadata>;
+export declare const DEFAULT_MODELS: Record<string, string>;
+export declare const DEFAULT_MINI_MODELS: Record<string, string>;
+export declare const API_KEY_ENV_VARS: Record<string, string[]>;
+export declare const ALLOWED_EXTENSIONS: Set<string>;
+export declare const IGNORED_DIRS: Set<string>;
+/**
+ * Dependency manifest files that should be hoisted to the top of the serialized
+ * source tree so the AI reads them FIRST, preventing framework hallucination.
+ */
+export declare const DEPENDENCY_MANIFESTS: Set<string>;

package/dist/constants.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPENDENCY_MANIFESTS = exports.IGNORED_DIRS = exports.ALLOWED_EXTENSIONS = exports.API_KEY_ENV_VARS = exports.DEFAULT_MINI_MODELS = exports.DEFAULT_MODELS = exports.MODEL_CATALOG = exports.PROVIDER_OPENAI = exports.PROVIDER_ANTHROPIC = exports.PROVIDER_GEMINI = void 0;
+exports.PROVIDER_GEMINI = "gemini";
+exports.PROVIDER_ANTHROPIC = "anthropic";
+exports.PROVIDER_OPENAI = "openai";
+exports.MODEL_CATALOG = {
+    // Google Gemini (2026)
+    "gemini/gemini-3.1-pro": { provider: exports.PROVIDER_GEMINI, tier: "primary" },
+    "gemini/gemini-3.1-flash": { provider: exports.PROVIDER_GEMINI, tier: "mini" },
+    "gemini/gemini-3-deep-think": { provider: exports.PROVIDER_GEMINI, tier: "primary" },
+    // Anthropic Claude (2026)
+    "anthropic/claude-opus-4.6": { provider: exports.PROVIDER_ANTHROPIC, tier: "primary" },
+    "anthropic/claude-sonnet-4.6": { provider: exports.PROVIDER_ANTHROPIC, tier: "primary" },
+    "anthropic/claude-sonnet-5": { provider: exports.PROVIDER_ANTHROPIC, tier: "primary" },
+    "anthropic/claude-haiku-4.5": { provider: exports.PROVIDER_ANTHROPIC, tier: "mini" },
+    "anthropic/claude-haiku-3-20250519": { provider: exports.PROVIDER_ANTHROPIC, tier: "mini" },
+    // OpenAI (2026)
+    "openai/gpt-5.3": { provider: exports.PROVIDER_OPENAI, tier: "primary" },
+    "openai/gpt-5.3-codex": { provider: exports.PROVIDER_OPENAI, tier: "primary" },
+    "openai/gpt-5.2": { provider: exports.PROVIDER_OPENAI, tier: "primary" },
+    "openai/gpt-4o": { provider: exports.PROVIDER_OPENAI, tier: "primary" },
+    "openai/gpt-4o-mini": { provider: exports.PROVIDER_OPENAI, tier: "mini" },
+};
+exports.DEFAULT_MODELS = {
+    [exports.PROVIDER_GEMINI]: "gemini/gemini-3.1-pro",
+    [exports.PROVIDER_ANTHROPIC]: "anthropic/claude-sonnet-4.6",
+    [exports.PROVIDER_OPENAI]: "openai/gpt-4o",
+};
+exports.DEFAULT_MINI_MODELS = {
+    [exports.PROVIDER_GEMINI]: "gemini/gemini-3.1-flash",
+    [exports.PROVIDER_ANTHROPIC]: "anthropic/claude-haiku-3-20250519",
+    [exports.PROVIDER_OPENAI]: "openai/gpt-4o-mini",
+};
+exports.API_KEY_ENV_VARS = {
+    [exports.PROVIDER_GEMINI]: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    [exports.PROVIDER_ANTHROPIC]: ["ANTHROPIC_API_KEY"],
+    [exports.PROVIDER_OPENAI]: ["OPENAI_API_KEY"],
+};
+exports.ALLOWED_EXTENSIONS = new Set([
+    ".py",
+    ".js",
+    ".ts",
+    ".jsx",
+    ".tsx",
+    ".vue",
+    ".java",
+    ".md",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".txt",
+    ".html",
+    ".css",
+    ".scss",
+    ".less",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cs",
+    ".go",
+    ".rb",
+    ".php",
+    ".rs",
+    ".sh",
+    ".swift",
+    ".kt",
+    ".sql",
+    ".xml",
+    ".toml",
+    ".ini",
+    ".dart",
+    ".scala",
+    ".r",
+    ".m",
+    ".pl",
+]);
+exports.IGNORED_DIRS = new Set([
+    "node_modules",
+    "__pycache__",
+    "venv",
+    "env",
+    "dist",
+    "build",
+    "target",
+    "vendor",
+    "bin",
+    "obj",
+    "out",
+    "coverage",
+    "logs",
+    "tmp",
+    "temp",
+    "packages",
+    "pkg",
+    ".git",
+]);
+/**
+ * Dependency manifest files that should be hoisted to the top of the serialized
+ * source tree so the AI reads them FIRST, preventing framework hallucination.
+ */
+exports.DEPENDENCY_MANIFESTS = new Set([
+    "requirements.txt",
+    "pyproject.toml",
+    "Pipfile",
+    "setup.py",
+    "setup.cfg",
+    "go.mod",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "Gemfile",
+    "composer.json",
+    "Package.swift",
+    "Makefile",
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "package.json",
+]);

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+console.log("Sylva initialized");

package/dist/modelConfig.d.ts

@@ -0,0 +1,14 @@
+export interface ModelMetadata {
+    provider: string;
+    tier: "primary" | "mini";
+}
+export interface ModelConfig {
+    provider: string;
+    model: string;
+    model_mini: string;
+    api_key: string;
+}
+export declare function resolveApiKey(provider: string): string;
+export declare function resolveModelConfig(modelArg?: string): ModelConfig;
+export declare function getLanguageModelService(config: ModelConfig, isMini?: boolean): any;
+export declare function listSupportedModels(): string;

package/dist/modelConfig.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveApiKey = resolveApiKey;
+exports.resolveModelConfig = resolveModelConfig;
+exports.getLanguageModelService = getLanguageModelService;
+exports.listSupportedModels = listSupportedModels;
+const ax_1 = require("@ax-llm/ax");
+const constants_1 = require("./constants");
+function resolveApiKey(provider) {
+    for (const envVar of constants_1.API_KEY_ENV_VARS[provider]) {
+        if (process.env[envVar])
+            return process.env[envVar];
+    }
+    throw new Error(`Environment variable(s) ${constants_1.API_KEY_ENV_VARS[provider].join(" or ")} not set for provider ${provider}. Exiting.`);
+}
+function resolveModelConfig(modelArg) {
+    let arg = modelArg || process.env.AUTOSKILL_MODEL || constants_1.PROVIDER_GEMINI;
+    arg = arg.trim();
+    let modelName = arg;
+    if (constants_1.DEFAULT_MODELS[arg]) {
+        modelName = constants_1.DEFAULT_MODELS[arg];
+    }
+    else if (!constants_1.MODEL_CATALOG[arg]) {
+        throw new Error(`Unknown model '${arg}'. Supported models:\n  ${Object.keys(constants_1.MODEL_CATALOG).sort().join(", ")}`);
+    }
+    const provider = constants_1.MODEL_CATALOG[modelName].provider;
+    const apiKey = resolveApiKey(provider);
+    const miniName = constants_1.DEFAULT_MINI_MODELS[provider];
+    return {
+        provider,
+        model: modelName,
+        model_mini: miniName,
+        api_key: apiKey,
+    };
+}
+function getLanguageModelService(config, isMini = true) {
+    const targetModel = isMini ? config.model_mini : config.model;
+    const rawModelName = targetModel.split("/")[1]; // Strip provider prefix
+    if (config.provider === constants_1.PROVIDER_GEMINI) {
+        return new ax_1.AxAIGoogleGemini({
+            apiKey: config.api_key,
+            config: { model: rawModelName },
+        });
+    }
+    else if (config.provider === constants_1.PROVIDER_ANTHROPIC) {
+        return new ax_1.AxAIAnthropic({
+            apiKey: config.api_key,
+            config: { model: rawModelName },
+        });
+    }
+    else {
+        return new ax_1.AxAIOpenAI({
+            apiKey: config.api_key,
+            config: { model: rawModelName },
+        });
+    }
+}
+function listSupportedModels() {
+    let output = "\nSupported models:\n";
+    let currentProvider = "";
+    for (const [name, meta] of Object.entries(constants_1.MODEL_CATALOG)) {
+        if (meta.provider !== currentProvider) {
+            currentProvider = meta.provider;
+            output += `  ${currentProvider.toUpperCase()}\n`;
+        }
+        let defaultTag = "";
+        if (name === constants_1.DEFAULT_MODELS[meta.provider]) {
+            defaultTag = "  (default)";
+        }
+        else if (name === constants_1.DEFAULT_MINI_MODELS[meta.provider]) {
+            defaultTag = "  (default mini)";
+        }
+        output += `    ${name}${defaultTag}\n`;
+    }
+    return output;
+}

package/dist/modules.d.ts

@@ -0,0 +1,53 @@
+import { AgentsMdSections, TreeType } from "./utils";
+export declare class CodebaseConventionExtractor {
+    private maxIterations;
+    constructor(maxIterations?: number);
+    extract(sourceTree: {
+        [key: string]: TreeType;
+    }): Promise<{
+        analyzer: import("@ax-llm/ax").AxAgent<{
+            readonly sourceContext: string;
+        }, {
+            readonly projectOverview: string;
+        } & {
+            readonly agentPersona: string;
+        } & {
+            readonly techStack: string;
+        } & {
+            readonly directoryStructure: string;
+        } & {
+            readonly executionCommands: string;
+        } & {
+            readonly codeStyleAndFormatting: string;
+        } & {
+            readonly architectureAndDesignPatterns: string;
+        } & {
+            readonly antiPatternsAndRestrictions: string;
+        } & {
+            readonly dependencyManagement: string;
+        } & {
+            readonly stateManagementGuidelines: string;
+        } & {
+            readonly databaseAndDataHandling: string;
+        } & {
+            readonly errorHandlingAndLogging: string;
+        } & {
+            readonly testingStrategy: string;
+        } & {
+            readonly securityAndCompliance: string;
+        } & {
+            readonly gitAndVersionControl: string;
+        } & {
+            readonly documentationStandards: string;
+        } & {
+            readonly agentWorkflow: string;
+        } & {
+            readonly fewShotExamples: string;
+        }>;
+        contextString: string;
+    }>;
+    compileMarkdown(llm: any, extractResult: any): Promise<string>;
+}
+export declare class AgentsMdCreator {
+    extractAndCompileSections(llm: any, conventionsMarkdown: string, repositoryName: string): Promise<AgentsMdSections>;
+}

package/dist/modules.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentsMdCreator = exports.CodebaseConventionExtractor = void 0;
+const ax_1 = require("@ax-llm/ax");
+const prompts_1 = require("./prompts");
+// We must serialize the source tree into a text/markdown format to feed into AxAgent context.
+function serializeSourceTree(tree, indent = "") {
+    let output = "";
+    for (const [key, value] of Object.entries(tree)) {
+        if (typeof value === "string") {
+            output += `${indent}- File: ${key}\n`;
+            output += `${indent}  Content:\n\`\`\`\n${value}\n\`\`\`\n\n`;
+        }
+        else {
+            output += `${indent}- Directory: ${key}/\n`;
+            output += serializeSourceTree(value, indent + "  ");
+        }
+    }
+    return output;
+}
+class CodebaseConventionExtractor {
+    maxIterations;
+    constructor(maxIterations = 35) {
+        this.maxIterations = maxIterations;
+    }
+    async extract(sourceTree) {
+        console.log("=> Preparing and serializing Source Tree for RLM analysis...");
+        const contextString = serializeSourceTree(sourceTree);
+        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;
+        // Pass config properties properly conforming to AxAgentConfig
+        const analyzer = (0, ax_1.agent)(agentSig, {
+            agentIdentity: prompts_1.CODEBASE_ANALYZER_IDENTITY,
+            contextFields: ["sourceContext"],
+            runtime: new ax_1.AxJSRuntime(),
+            maxLlmCalls: this.maxIterations,
+        });
+        // We run the agent forwarding the generic LLM.
+        // We will receive the initialized `llm` instance from the CLI.
+        return {
+            analyzer,
+            contextString,
+        };
+    }
+    async compileMarkdown(llm, extractResult) {
+        console.log("=> Compiling Codebase Analysis into Cohesive Markdown...");
+        // 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);
+        return finalResult.markdownDocument;
+    }
+}
+exports.CodebaseConventionExtractor = CodebaseConventionExtractor;
+class AgentsMdCreator {
+    async extractAndCompileSections(llm, conventionsMarkdown, repositoryName) {
+        console.log(`=> Extracting individual AGENTS.md sections for repository: ${repositoryName}...`);
+        // Equivalent to ExtractAgentsSections via ChainOfThought
+        const sectionSig = prompts_1.EXTRACT_AGENTS_SECTIONS_SIGNATURE;
+        const sectionExtractor = (0, ax_1.ax)(sectionSig);
+        const sections = await sectionExtractor.forward(llm, {
+            conventionsMarkdown,
+            repositoryName,
+        });
+        return sections;
+    }
+}
+exports.AgentsMdCreator = AgentsMdCreator;

package/dist/prompts.d.ts

@@ -0,0 +1,119 @@
+export declare const CODEBASE_ANALYSIS_SIGNATURE: import("@ax-llm/ax").AxSignature<{
+    readonly sourceContext: string;
+}, {
+    readonly projectOverview: string;
+} & {
+    readonly agentPersona: string;
+} & {
+    readonly techStack: string;
+} & {
+    readonly directoryStructure: string;
+} & {
+    readonly executionCommands: string;
+} & {
+    readonly codeStyleAndFormatting: string;
+} & {
+    readonly architectureAndDesignPatterns: string;
+} & {
+    readonly antiPatternsAndRestrictions: string;
+} & {
+    readonly dependencyManagement: string;
+} & {
+    readonly stateManagementGuidelines: string;
+} & {
+    readonly databaseAndDataHandling: string;
+} & {
+    readonly errorHandlingAndLogging: string;
+} & {
+    readonly testingStrategy: string;
+} & {
+    readonly securityAndCompliance: string;
+} & {
+    readonly gitAndVersionControl: string;
+} & {
+    readonly documentationStandards: string;
+} & {
+    readonly agentWorkflow: string;
+} & {
+    readonly fewShotExamples: string;
+}>;
+export declare const CODEBASE_ANALYZER_IDENTITY: {
+    name: string;
+    description: string;
+};
+export declare const COMPILE_CONVENTIONS_SIGNATURE: import("@ax-llm/ax").AxSignature<{
+    readonly projectOverview: string;
+} & {
+    readonly agentPersona: string;
+} & {
+    readonly techStack: string;
+} & {
+    readonly directoryStructure: string;
+} & {
+    readonly executionCommands: string;
+} & {
+    readonly codeStyleAndFormatting: string;
+} & {
+    readonly architectureAndDesignPatterns: string;
+} & {
+    readonly antiPatternsAndRestrictions: string;
+} & {
+    readonly dependencyManagement: string;
+} & {
+    readonly stateManagementGuidelines: string;
+} & {
+    readonly databaseAndDataHandling: string;
+} & {
+    readonly errorHandlingAndLogging: string;
+} & {
+    readonly testingStrategy: string;
+} & {
+    readonly securityAndCompliance: string;
+} & {
+    readonly gitAndVersionControl: string;
+} & {
+    readonly documentationStandards: string;
+} & {
+    readonly agentWorkflow: string;
+} & {
+    readonly fewShotExamples: string;
+}, {
+    readonly markdownDocument: string;
+}>;
+export declare const EXTRACT_AGENTS_SECTIONS_SIGNATURE: import("@ax-llm/ax").AxSignature<{
+    readonly conventionsMarkdown: string;
+} & {
+    readonly repositoryName: string;
+}, {
+    readonly projectOverview: string;
+} & {
+    readonly techStack: string;
+} & {
+    readonly architecture: string;
+} & {
+    readonly codeStyle: string;
+} & {
+    readonly antiPatternsAndRestrictions: string;
+} & {
+    readonly databaseAndState: string;
+} & {
+    readonly errorHandlingAndLogging: string;
+} & {
+    readonly testingCommands: string;
+} & {
+    readonly testingGuidelines: string;
+} & {
+    readonly securityAndCompliance: string;
+} & {
+    readonly dependenciesAndEnvironment: string;
+} & {
+    readonly prAndGitRules: string;
+} & {
+    readonly documentationStandards: string;
+} & {
+    readonly commonPatterns: string;
+} & {
+    readonly agentWorkflow: string;
+} & {
+    readonly fewShotExamples: string;
+}>;

package/dist/prompts.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRACT_AGENTS_SECTIONS_SIGNATURE = exports.COMPILE_CONVENTIONS_SIGNATURE = exports.CODEBASE_ANALYZER_IDENTITY = exports.CODEBASE_ANALYSIS_SIGNATURE = void 0;
+const ax_1 = require("@ax-llm/ax");
+exports.CODEBASE_ANALYSIS_SIGNATURE = (0, ax_1.f)()
+    .input("sourceContext", ax_1.f.string())
+    .output("projectOverview", ax_1.f.string("Project Overview & Context: Exhaustively describe all primary sub-services, their purpose, and what languages or frameworks power them."))
+    .output("agentPersona", ax_1.f.string("Agent Persona / Role"))
+    .output("techStack", ax_1.f.string("Tech Stack & Versions: List EVERY distinct language, library, database, and external API dependency used. WARNING: Do NOT guess frameworks based on assumptions or the presence of a package.json. You must explicitly scan the actual code files (e.g. imports in .py, .ts, .js) and dependency manifests (e.g. requirements.txt, go.mod) to determine the EXACT tech stack."))
+    .output("directoryStructure", ax_1.f.string("Directory Structure (The Map): Deeply map out all root folders, separating different sub-projects (frontend vs backend) and their specific structures."))
+    .output("executionCommands", ax_1.f.string("Execution Commands: Exact terminal commands to run or build."))
+    .output("codeStyleAndFormatting", ax_1.f.string("Code Style & Formatting: Language-specific formatting and strictly enforced linting rules."))
+    .output("architectureAndDesignPatterns", ax_1.f.string("Architecture & Design Patterns: Detailed cross-service logical flow, API boundaries, and system design logic."))
+    .output("antiPatternsAndRestrictions", ax_1.f.string("Anti-Patterns & Restrictions"))
+    .output("dependencyManagement", ax_1.f.string("Dependency Management"))
+    .output("stateManagementGuidelines", ax_1.f.string("State Management Guidelines"))
+    .output("databaseAndDataHandling", ax_1.f.string("Database & Data Handling"))
+    .output("errorHandlingAndLogging", ax_1.f.string("Error Handling & Logging"))
+    .output("testingStrategy", ax_1.f.string("Testing Strategy"))
+    .output("securityAndCompliance", ax_1.f.string("Security & Compliance"))
+    .output("gitAndVersionControl", ax_1.f.string("Git & Version Control"))
+    .output("documentationStandards", ax_1.f.string("Documentation Standards"))
+    .output("agentWorkflow", ax_1.f.string("Agent Workflow / SOP"))
+    .output("fewShotExamples", ax_1.f.string("Few-Shot Examples: Specific code snippets showing 'how to do X correctly'."))
+    .build();
+exports.CODEBASE_ANALYZER_IDENTITY = {
+    name: "CodebaseAnalyzer",
+    description: "A hyper-detailed technical architect generating strict developer manifests. You must analyze the structural backbone, data flow, and day-to-day coding conventions of the application using recursive analysis of the source code. NEVER hallucinate frameworks; always verify by scanning actual source imports and dependency files.",
+};
+exports.COMPILE_CONVENTIONS_SIGNATURE = (0, ax_1.f)()
+    .input("projectOverview", ax_1.f.string("Project Overview & Context."))
+    .input("agentPersona", ax_1.f.string("Agent Persona / Role."))
+    .input("techStack", ax_1.f.string("Tech Stack & Versions."))
+    .input("directoryStructure", ax_1.f.string("Directory Structure (The Map)."))
+    .input("executionCommands", ax_1.f.string("Execution Commands."))
+    .input("codeStyleAndFormatting", ax_1.f.string("Code Style & Formatting."))
+    .input("architectureAndDesignPatterns", ax_1.f.string("Architecture & Design Patterns."))
+    .input("antiPatternsAndRestrictions", ax_1.f.string("Anti-Patterns & Restrictions."))
+    .input("dependencyManagement", ax_1.f.string("Dependency Management."))
+    .input("stateManagementGuidelines", ax_1.f.string("State Management Guidelines."))
+    .input("databaseAndDataHandling", ax_1.f.string("Database & Data Handling."))
+    .input("errorHandlingAndLogging", ax_1.f.string("Error Handling & Logging."))
+    .input("testingStrategy", ax_1.f.string("Testing Strategy."))
+    .input("securityAndCompliance", ax_1.f.string("Security & Compliance."))
+    .input("gitAndVersionControl", ax_1.f.string("Git & Version Control."))
+    .input("documentationStandards", ax_1.f.string("Documentation Standards."))
+    .input("agentWorkflow", ax_1.f.string("Agent Workflow / SOP."))
+    .input("fewShotExamples", ax_1.f.string("Few-Shot Examples."))
+    .output("markdownDocument", ax_1.f.string("Comprehensive CODEBASE_CONVENTIONS.md document formatted with clear headings, bullet points, and specific code/file snippets as evidence."))
+    .build();
+exports.EXTRACT_AGENTS_SECTIONS_SIGNATURE = (0, ax_1.f)()
+    .input("conventionsMarkdown", ax_1.f.string("The extracted architectural, data flow, and granular coding conventions"))
+    .input("repositoryName", ax_1.f.string("The name of the repository or project"))
+    .output("projectOverview", ax_1.f.string("Comprehensive description of the project: what it does, its tech stack, its primary languages, and its overall purpose and functionality."))
+    .output("techStack", ax_1.f.string("Explicit and exhaustive list of supported languages, frameworks, UI libraries, backend runtimes, and tools used in the repository. Annotate what each technology is used for (e.g., 'X Framework for UI', 'Y Language for REST Services')."))
+    .output("architecture", ax_1.f.string("Deep mapping of where things live: directory layout, key modules, entry points, and their responsibilities. You MUST generate an ASCII diagram showing the architecture, module relationships, and sub-services. Break down complex monorepos explicitly (e.g., separating frontend code vs backend code)."))
+    .output("codeStyle", ax_1.f.string("Granular coding standards observed: language version, formatting, naming conventions, import ordering, type-hinting rules, preferred patterns vs anti-patterns. Explicitly mention how different stacks in a monorepo communicate (e.g., REST, GraphQL, etc.) and how proprietary or 3rd-party external APIs are wrapped or invoked. Provide concrete examples from the codebase. All code blocks must be properly opened AND closed with triple backticks."))
+    .output("antiPatternsAndRestrictions", ax_1.f.string("Specific anti-patterns and 'NEVER do this' rules the AI must strictly avoid."))
+    .output("databaseAndState", ax_1.f.string("Guidelines on how data and state should flow through the application, including databases, external API data syncing, or state managers."))
+    .output("errorHandlingAndLogging", ax_1.f.string("Conventions for handling exceptions and formatting logs, highlighting any specific utilities to use."))
+    .output("testingCommands", ax_1.f.string("Exact CLI commands to build, lint, test, and run the project. Include per-file test commands if available. Format as a bullet list of runnable commands. All code blocks must be properly opened AND closed with triple backticks."))
+    .output("testingGuidelines", ax_1.f.string("How tests should be written in this project: framework used, file placement conventions, naming patterns, mocking strategies, and coverage expectations. All code blocks must be properly opened AND closed with triple backticks."))
+    .output("securityAndCompliance", ax_1.f.string("Strict security guardrails, such as rules against exposing secrets or logging PII."))
+    .output("dependenciesAndEnvironment", ax_1.f.string("How to install dependencies, required environment variables, external service setup, and supported runtime versions."))
+    .output("prAndGitRules", ax_1.f.string("Commit message format, branch naming conventions, required checks before merging, and any PR review policies observed in the codebase."))
+    .output("documentationStandards", ax_1.f.string("Standards for writing docstrings, comments, and updating system/user documentation."))
+    .output("commonPatterns", ax_1.f.string("Recurring design patterns, error handling idioms, logging conventions, and strict 'ALWAYS do X / NEVER do Y' rules observed across the codebase. All code blocks must be properly opened AND closed with triple backticks."))
+    .output("agentWorkflow", ax_1.f.string("Standard Operating Procedure (SOP) for how the AI should approach generic or specific tasks in this codebase."))
+    .output("fewShotExamples", ax_1.f.string("Concrete 'Good' vs 'Bad' code snippets to perfectly align the agent via demonstration. Provide detailed examples of standard implementation paths. All code blocks must be properly opened AND closed with triple backticks."))
+    .build();

package/dist/utils.d.ts

@@ -0,0 +1,41 @@
+export type TreeType = string | {
+    [key: string]: TreeType;
+};
+/**
+ * Recursively load the source tree into a nested dictionary,
+ * skipping ignored directories and unsupported extensions to save LLM context.
+ */
+export declare function loadSourceTree(rootDir: string): {
+    [key: string]: TreeType;
+};
+/**
+ * Clones a Git repository to the specified destination handling child_process execution.
+ */
+export declare function cloneRepo(repoUrl: string, destDir: string): void;
+/**
+ * Saves compiled AGENTS.md back to disk on a standardized path.
+ */
+export declare function saveAgentsToDisk(repoName: string, agentsContent: string, baseDir?: string): void;
+export interface AgentsMdSections {
+    projectOverview?: string;
+    agentPersona?: string;
+    techStack?: string;
+    architecture?: string;
+    codeStyle?: string;
+    antiPatternsAndRestrictions?: string;
+    databaseAndState?: string;
+    errorHandlingAndLogging?: string;
+    testingCommands?: string;
+    testingGuidelines?: string;
+    securityAndCompliance?: string;
+    dependenciesAndEnvironment?: string;
+    prAndGitRules?: string;
+    documentationStandards?: string;
+    commonPatterns?: string;
+    agentWorkflow?: string;
+    fewShotExamples?: string;
+}
+/**
+ * Joins evaluated section variables together into the uniform AGENTS.md map.
+ */
+export declare function compileAgentsMd(sections: AgentsMdSections, repoName: string): string;

package/dist/utils.js

@@ -0,0 +1,173 @@
+"use strict";
+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.loadSourceTree = loadSourceTree;
+exports.cloneRepo = cloneRepo;
+exports.saveAgentsToDisk = saveAgentsToDisk;
+exports.compileAgentsMd = compileAgentsMd;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const constants_1 = require("./constants");
+/**
+ * Recursively load the source tree into a nested dictionary,
+ * skipping ignored directories and unsupported extensions to save LLM context.
+ */
+function loadSourceTree(rootDir) {
+    const tree = {};
+    if (!fs.existsSync(rootDir))
+        return tree;
+    const entries = fs.readdirSync(rootDir);
+    for (const entry of entries) {
+        if (constants_1.IGNORED_DIRS.has(entry) || entry === ".git" || entry === ".DS_Store") {
+            continue;
+        }
+        const fullPath = path.join(rootDir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(fullPath);
+        }
+        catch {
+            console.log(`Failed to parse file: ${fullPath}, skipping.`);
+            continue;
+        }
+        if (stat.isDirectory()) {
+            if (!entry.startsWith(".")) {
+                const subTree = loadSourceTree(fullPath);
+                if (Object.keys(subTree).length > 0) {
+                    tree[entry] = subTree;
+                }
+            }
+        }
+        else {
+            const ext = path.extname(entry).toLowerCase();
+            // Allow specific files even without standard extension
+            if (!constants_1.ALLOWED_EXTENSIONS.has(ext) && entry !== "Dockerfile" && entry !== "Makefile")
+                continue;
+            try {
+                const content = fs.readFileSync(fullPath, "utf-8");
+                if (content.length < 500000) {
+                    tree[entry] = content;
+                }
+                else {
+                    console.warn(`File ${fullPath} skipped due to being too large (${content.length} chars)`);
+                }
+            }
+            catch (error) {
+                console.warn(`File ${fullPath} skipped due to read/encoding issues: ${error.message}`);
+            }
+        }
+    }
+    // Hoist dependency manifests to the top of the tree so the AI reads them first
+    const hoisted = {};
+    const rest = {};
+    for (const [key, value] of Object.entries(tree)) {
+        if (constants_1.DEPENDENCY_MANIFESTS.has(key)) {
+            hoisted[key] = value;
+        }
+        else {
+            rest[key] = value;
+        }
+    }
+    return { ...hoisted, ...rest };
+}
+/**
+ * Clones a Git repository to the specified destination handling child_process execution.
+ */
+function cloneRepo(repoUrl, destDir) {
+    console.log(`Cloning ${repoUrl} into ${destDir}...`);
+    try {
+        (0, child_process_1.execSync)(`git clone --depth 1 ${repoUrl} ${destDir}`, { stdio: "pipe" });
+    }
+    catch (error) {
+        console.error(`Failed to clone repository: ${error.message}`);
+        if (error.stderr)
+            console.error(error.stderr.toString());
+        throw new Error("Git clone failed", { cause: error });
+    }
+}
+/**
+ * Saves compiled AGENTS.md back to disk on a standardized path.
+ */
+function saveAgentsToDisk(repoName, agentsContent, baseDir = "projects") {
+    let cleanContent = agentsContent.trim();
+    // Strip surrounding markdown code blocks if the LLM wrapped it completely
+    cleanContent = cleanContent.replace(/^```(?:markdown)?\s*\n/, "");
+    cleanContent = cleanContent.replace(/```\s*$/, "");
+    cleanContent = cleanContent.trim();
+    const folderName = repoName.toLowerCase().replace(/\s+/g, "-");
+    const targetDir = path.join(baseDir, folderName);
+    fs.mkdirSync(targetDir, { recursive: true });
+    const filePath = path.join(targetDir, "AGENTS.md");
+    try {
+        fs.writeFileSync(filePath, cleanContent, "utf-8");
+        console.log(`✅ Successfully saved AGENTS.md to: ${filePath}`);
+    }
+    catch (error) {
+        console.error(`Failed to save AGENTS.md to ${filePath}: ${error.message}`);
+    }
+}
+const AGENTS_SECTION_HEADINGS = [
+    ["projectOverview", "Project Overview"],
+    ["agentPersona", "Agent Persona"],
+    ["techStack", "Tech Stack"],
+    ["architecture", "Architecture"],
+    ["codeStyle", "Code Style"],
+    ["antiPatternsAndRestrictions", "Anti-Patterns & Restrictions"],
+    ["databaseAndState", "Database & State Management"],
+    ["errorHandlingAndLogging", "Error Handling & Logging"],
+    ["testingCommands", "Testing Commands"],
+    ["testingGuidelines", "Testing Guidelines"],
+    ["securityAndCompliance", "Security & Compliance"],
+    ["dependenciesAndEnvironment", "Dependencies & Environment"],
+    ["prAndGitRules", "PR & Git Rules"],
+    ["documentationStandards", "Documentation Standards"],
+    ["commonPatterns", "Common Patterns"],
+    ["agentWorkflow", "Agent Workflow / SOP"],
+    ["fewShotExamples", "Few-Shot Examples"],
+];
+/**
+ * Joins evaluated section variables together into the uniform AGENTS.md map.
+ */
+function compileAgentsMd(sections, repoName) {
+    const parts = [`# AGENTS.md — ${repoName}\n`];
+    for (const [key, heading] of AGENTS_SECTION_HEADINGS) {
+        const content = sections[key];
+        if (content && content.trim() !== "") {
+            parts.push(`## ${heading}\n\n${content.trim()}\n`);
+        }
+    }
+    return parts.join("\n");
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@thelogicatelier/sylva",
+  "version": "1.0.4",
+  "description": "Auto-generate AGENTS.md for your repository using Ax-LLM. Analyze the structural backbone, data flow, and day-to-day coding conventions natively.",
+  "main": "dist/index.js",
+  "bin": {
+    "sylva": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node src/cli.ts",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/ tests/src/",
+    "lint:fix": "eslint src/ tests/src/ --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/src/**/*.ts\"",
+    "prepare": "husky",
+    "docs:build": "npx honkit@5.1.4 build docs docs-site",
+    "docs:serve": "npx honkit@5.1.4 serve docs",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/achatt89/sylva.git"
+  },
+  "keywords": [
+    "agents",
+    "llm",
+    "documentation",
+    "cli",
+    "automation",
+    "ai",
+    "typescript",
+    "ax-llm"
+  ],
+  "author": "Abhijit Chatterjee",
+  "license": "MIT",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/achatt89/sylva/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://achatt89.github.io/sylva/",
+  "dependencies": {
+    "@ax-llm/ax": "^19.0.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.0",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "prettier": "^3.8.1",
+    "typescript-eslint": "^8.56.1"
+  }
+}