create-bk-agent 0.20.0 → 0.21.0

package/README.md

@@ -1,5 +1,7 @@
 # create-bk-agent
 
+**Status: stable** — works and is maintained; will not be expanded during the pilot phase.
+
 Scaffold a new [BackendKit agent](https://github.com/BackendKit-labs/backendkit-agent-framework) project in seconds — or add capabilities to an existing one.
 
 ## Create a project
@@ -11,7 +13,7 @@ npx create-bk-agent my-project
 The CLI asks three questions and generates a production-ready project:
 
 ```
-✨  create-bk-agent  v0.19.1
+✨  create-bk-agent  v0.20.0
 
 ? Project name:          my-project
 ? Architecture:          Multi-agent (orchestrator + specialists)

package/dist/src/add/detector.js

@@ -53,12 +53,16 @@ function detectProject(cwd) {
     };
     if (!deps['@backendkit-labs/agent-core'])
         return null;
+    const isEnterprise = !!deps['@backendkit-labs/agent-enterprise'];
     const engineFile = path.join(cwd, 'src', 'engine.ts');
     let architecture = 'unknown';
     let engineFnName = 'createEngine';
     if (fs.existsSync(engineFile)) {
         const content = fs.readFileSync(engineFile, 'utf-8');
-        if (content.includes('ORCHESTRATOR_PROFILE') || content.includes("id: 'orchestrator'")) {
+        if (isEnterprise && content.includes('ObsidianRAGProvider')) {
+            architecture = 'enterprise';
+        }
+        else if (content.includes('ORCHESTRATOR_PROFILE') || content.includes("id: 'orchestrator'")) {
             architecture = 'multi-agent';
         }
         else if (content.includes('export function create')) {
@@ -76,5 +80,6 @@ function detectProject(cwd) {
         serverFile: path.join(cwd, 'src', 'server.ts'),
         pkgFile,
         engineFnName,
+        isEnterprise,
     };
 }

package/dist/src/add/index.js

@@ -7,6 +7,7 @@ const specialist_1 = require("./modules/specialist");
 const tools_1 = require("./modules/tools");
 const mcp_client_1 = require("./modules/mcp-client");
 const plugin_1 = require("./modules/plugin");
+const knowledge_1 = require("./modules/knowledge");
 const HELP = `
 Usage: npx create-bk-agent add <module> [options]
 
@@ -21,6 +22,9 @@ Modules:
   tools <domain>        Add a tool file for a new domain
                         (creates src/tools/<domain>-tools.ts and patches engine.ts)
 
+  knowledge <path>      Add a folder or vault to the RAG knowledge base (enterprise agents)
+    --vault <path>        Register an entirely new Obsidian vault (instead of a subfolder)
+
   mcp-client <url>      Add a remote MCP server to the engine
     --name <s>            Name for the mcpServers entry (default: last URL segment)
 
@@ -31,6 +35,9 @@ Examples:
   npx create-bk-agent add server --port 4000
   npx create-bk-agent add specialist data-analyst
   npx create-bk-agent add tools github
+  npx create-bk-agent add knowledge ./docs
+  npx create-bk-agent add knowledge "04-Recursos/Backend"
+  npx create-bk-agent add knowledge --vault "C:/Company/HR-Vault"
   npx create-bk-agent add mcp-client http://localhost:3001/mcp --name billing
   npx create-bk-agent add plugin docker
   npx create-bk-agent add plugin k8s
@@ -68,6 +75,9 @@ function runAdd(args, cwd) {
         case 'plugin':
             (0, plugin_1.addPlugin)(info, rest);
             break;
+        case 'knowledge':
+            (0, knowledge_1.addKnowledge)(info, rest);
+            break;
         default:
             console.error(`\n✗  Unknown module: "${module}"\n`);
             console.log(HELP);

package/dist/src/add/modules/knowledge.js

@@ -0,0 +1,254 @@
+"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.addKnowledge = addKnowledge;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const patcher_1 = require("../patcher");
+function parseArgs(args) {
+    const vaultIdx = args.indexOf('--vault');
+    if (vaultIdx !== -1) {
+        const target = args[vaultIdx + 1];
+        if (!target)
+            return null;
+        return { target, isNewVault: true };
+    }
+    if (args[0])
+        return { target: args[0], isNewVault: false };
+    return null;
+}
+/**
+ * Adds `folderPath` to the `folders:` array inside ObsidianRAGProvider({...}).
+ *
+ * Handles three states of engine.ts:
+ *   1. `folders:` already exists (uncommented) → append entry
+ *   2. `// folders:` is commented out (template default) → uncomment + set
+ *   3. No `folders:` at all → insert before closing `}` of RAG constructor
+ */
+function patchFolders(engineFile, folderPath) {
+    if (!fs.existsSync(engineFile))
+        return 'no_rag_found';
+    const content = fs.readFileSync(engineFile, 'utf-8');
+    if (!content.includes('ObsidianRAGProvider'))
+        return 'no_rag_found';
+    const normalized = folderPath.replace(/\\/g, '/');
+    if (content.includes(`'${normalized}'`))
+        return 'already_exists';
+    // Case 1: folders array already exists (uncommented)
+    if (/\bfolders:\s*\[/.test(content)) {
+        const patched = content.replace(/(\bfolders:\s*\[)([^\]]*)(\])/, (_full, open, inner, close) => {
+            const trimmed = inner.trimEnd();
+            const needsComma = trimmed.length > 0 && !trimmed.endsWith(',');
+            return `${open}${inner}${needsComma ? ',' : ''}\n        '${normalized}',\n    ${close}`;
+        });
+        if (patched !== content) {
+            fs.writeFileSync(engineFile, patched);
+            return 'added';
+        }
+    }
+    // Case 2: folders line is commented out (// TODO: ... \n // folders: [...])
+    if (content.includes('// folders:') || content.includes('// TODO: restrict indexing')) {
+        const patched = content.replace(/[ \t]*\/\/\s*TODO:\s*restrict indexing[^\n]*\n[ \t]*\/\/\s*folders:[^\n]*\n/, `        folders: ['${normalized}'],\n`);
+        if (patched !== content) {
+            fs.writeFileSync(engineFile, patched);
+            return 'added';
+        }
+        // Fallback: just the commented folders line
+        const patched2 = content.replace(/[ \t]*\/\/\s*folders:[^\n]*\n/, `        folders: ['${normalized}'],\n`);
+        if (patched2 !== content) {
+            fs.writeFileSync(engineFile, patched2);
+            return 'added';
+        }
+    }
+    // Case 3: no folders key — insert before closing `}` of RAG constructor
+    const lines = content.split('\n');
+    let inRag = false;
+    let depth = 0;
+    let closeIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes('new ObsidianRAGProvider(')) {
+            inRag = true;
+            depth = 0;
+        }
+        if (inRag) {
+            depth += (lines[i].match(/\{/g) ?? []).length;
+            depth -= (lines[i].match(/\}/g) ?? []).length;
+            if (depth === 0) {
+                closeIdx = i;
+                break;
+            }
+        }
+    }
+    if (closeIdx === -1)
+        return 'no_rag_found';
+    lines.splice(closeIdx, 0, `        folders: ['${normalized}'],`);
+    fs.writeFileSync(engineFile, lines.join('\n'));
+    return 'added';
+}
+/**
+ * Adds a second ObsidianRAGProvider for a completely new vault and merges
+ * its tool into the existing tools registry.
+ * Used when --vault flag is passed to add a new vault, not just a folder.
+ */
+function addNewVault(engineFile, vaultPath) {
+    if (!fs.existsSync(engineFile))
+        return 'no_rag_found';
+    const content = fs.readFileSync(engineFile, 'utf-8');
+    if (!content.includes('ObsidianRAGProvider'))
+        return 'no_rag_found';
+    const normalized = vaultPath.replace(/\\/g, '/');
+    const varName = `rag_${path.basename(normalized).replace(/[^a-zA-Z0-9]/g, '_').toLowerCase()}`;
+    if (content.includes(normalized))
+        return 'already_exists';
+    // Insert new RAG instance after the first one
+    const ragBlock = [
+        '',
+        `    // Additional vault: ${path.basename(normalized)}`,
+        `    const ${varName} = new ObsidianRAGProvider({`,
+        `        vaultPath:      '${normalized}',`,
+        `        ollamaHost:     config.ollamaHost,`,
+        `        embeddingModel: config.embeddingModel,`,
+        `    });`,
+    ].join('\n');
+    const patched = content.replace(/(const rag = new ObsidianRAGProvider\(\{[\s\S]*?\}\);)/, `$1\n${ragBlock}`);
+    // Register the new tool
+    const withTool = patched.replace(/tools\s*\n?\s*\.register\(rag\.createTool\(\)\)/, `tools\n        .register(rag.createTool())\n        .register(${varName}.createTool())`);
+    if (withTool === content)
+        return 'no_rag_found';
+    fs.writeFileSync(engineFile, withTool);
+    return 'added';
+}
+// ── Non-enterprise setup ──────────────────────────────────────────────────────
+function setupRagFromScratch(info, vaultPath) {
+    console.log('\n📦  Installing @backendkit-labs/agent-enterprise ...');
+    const added = (0, patcher_1.addPackageDependency)(info.pkgFile, '@backendkit-labs/agent-enterprise', '^0.1.0');
+    if (added) {
+        (0, child_process_1.execSync)('npm install', { cwd: info.cwd, stdio: 'inherit' });
+    }
+    if (!fs.existsSync(info.engineFile)) {
+        console.log('\n⚠  src/engine.ts not found — add RAG manually:');
+        printManualInstructions(vaultPath);
+        return;
+    }
+    const content = fs.readFileSync(info.engineFile, 'utf-8');
+    if (content.includes('ObsidianRAGProvider')) {
+        console.log('\n⚠  ObsidianRAGProvider already present in engine.ts');
+        return;
+    }
+    // Add import
+    (0, patcher_1.addImportLine)(info.engineFile, `import { ObsidianRAGProvider } from '@backendkit-labs/agent-enterprise';`);
+    // Insert RAG instance + tool registration
+    const normalized = vaultPath.replace(/\\/g, '/');
+    const ragBlock = [
+        '',
+        `    // Knowledge base (RAG over Obsidian vault)`,
+        `    const rag = new ObsidianRAGProvider({`,
+        `        vaultPath: '${normalized}',`,
+        `        // ollamaHost: process.env.OLLAMA_HOST ?? 'http://localhost:11434',`,
+        `        // embeddingModel: process.env.EMBEDDING_MODEL ?? 'nomic-embed-text',`,
+        `    });`,
+        '',
+    ].join('\n');
+    // Insert before first ToolRegistry or ToolRegistry instantiation
+    let patched = fs.readFileSync(info.engineFile, 'utf-8');
+    patched = patched.replace(/(const tools = new ToolRegistry\(\);)/, `${ragBlock}    $1`);
+    // Register the tool
+    patched = patched.replace(/(const tools = new ToolRegistry\(\);[\s\S]*?tools)/, (match) => match.replace(/tools\s*\n?\s*\.register\(/, `tools\n        .register(rag.createTool())\n        .register(`));
+    fs.writeFileSync(info.engineFile, patched);
+    console.log('\n✓  Added ObsidianRAGProvider to src/engine.ts');
+    console.log('✓  Registered search_knowledge tool');
+    console.log('\n  Make sure Ollama is running and nomic-embed-text is available:');
+    console.log('  ollama pull nomic-embed-text\n');
+}
+function printManualInstructions(vaultPath) {
+    const normalized = vaultPath.replace(/\\/g, '/');
+    console.log(`
+  1. Import in engine.ts:
+     import { ObsidianRAGProvider } from '@backendkit-labs/agent-enterprise';
+
+  2. Create RAG instance:
+     const rag = new ObsidianRAGProvider({ vaultPath: '${normalized}' });
+
+  3. Register tool:
+     tools.register(rag.createTool());
+`);
+}
+// ── Main export ───────────────────────────────────────────────────────────────
+const USAGE = `
+Usage: npx create-bk-agent add knowledge <folder-path>
+       npx create-bk-agent add knowledge --vault <vault-path>
+
+Examples:
+  npx create-bk-agent add knowledge ./docs
+  npx create-bk-agent add knowledge "04-Recursos/Backend"
+  npx create-bk-agent add knowledge --vault "C:/Company/HR-Vault"
+`;
+function addKnowledge(info, args) {
+    const parsed = parseArgs(args);
+    if (!parsed) {
+        console.log(USAGE);
+        process.exit(1);
+    }
+    const absPath = path.resolve(info.cwd, parsed.target);
+    if (!info.isEnterprise) {
+        console.log('\n⚠  This project does not use @backendkit-labs/agent-enterprise.');
+        console.log('   Setting up RAG from scratch...\n');
+        setupRagFromScratch(info, absPath);
+        return;
+    }
+    let result;
+    if (parsed.isNewVault) {
+        result = addNewVault(info.engineFile, absPath);
+    }
+    else {
+        result = patchFolders(info.engineFile, absPath);
+    }
+    switch (result) {
+        case 'added':
+            console.log(`\n✓  Added knowledge source to src/engine.ts`);
+            console.log(`   Path: ${absPath}`);
+            console.log('\n   The vault will be re-indexed on next run (incremental — only new/changed files).\n');
+            break;
+        case 'already_exists':
+            console.log(`\n⚠  '${absPath}' is already registered in engine.ts\n`);
+            break;
+        case 'no_rag_found':
+            console.log('\n✗  Could not find ObsidianRAGProvider in src/engine.ts');
+            console.log('   Add it manually:\n');
+            printManualInstructions(absPath);
+            break;
+    }
+}

package/dist/src/index.js

@@ -57,6 +57,7 @@ function describeChoices(choices) {
         coding: 'Coding assistant',
         autonomous: 'Autonomous daemon',
         minimal: 'Minimal / embedded',
+        enterprise: 'Enterprise (local LLM + RAG)',
     };
     const deploy = {
         repl: 'Terminal REPL',
@@ -64,6 +65,7 @@ function describeChoices(choices) {
         'mcp-stdio': 'MCP Server (stdio)',
         hybrid: 'REPL + MCP Server',
         library: 'Library',
+        web: 'Web Server (chat + kanban)',
     };
     const archLabel = arch[choices.architecture] ?? choices.architecture;
     if (!choices.deployMode)
@@ -80,6 +82,27 @@ function buildNextSteps(choices) {
         return ['Configure triggers in src/index.ts', 'npm run dev'];
     if (arch === 'minimal')
         return ['Implement your LLM provider in src/index.ts', 'npm run dev'];
+    // Enterprise — local LLM + RAG
+    if (arch === 'enterprise') {
+        if (mode === 'web') {
+            return [
+                'Make sure Ollama is running:  ollama serve',
+                'Pull model:                   ollama pull llama3.2',
+                'Review vault path in .env (VAULT_PATH)',
+                'npm run dev              # indexes vault + starts server on :4001',
+                '# Chat:    http://localhost:4001/',
+                '# Kanban:  http://localhost:4001/#kanban',
+                '# Monitor: ws://localhost:4001/monitor',
+            ];
+        }
+        return [
+            'Make sure Ollama is running:  ollama serve',
+            'Pull required models:         ollama pull llama3.2 && ollama pull nomic-embed-text',
+            'Review your vault path in .env (VAULT_PATH)',
+            'Customize agents in src/agents/ for your business domain',
+            mode === 'repl' ? 'npm run dev' : 'npm run server',
+        ];
+    }
     // Layered architectures (multi-agent, single) — vary by deploy mode
     const domainSteps = arch === 'multi-agent'
         ? ['Rename agents/ and tools/ to match your domain', 'Implement tools in src/tools/']

package/dist/src/prompts.js

@@ -33,6 +33,11 @@ const ARCHITECTURE_CHOICES = [
         value: 'minimal',
         description: 'Best for embedding in an existing app or custom architecture',
     },
+    {
+        title: p('Enterprise', 22) + 'Local LLM + Obsidian knowledge base — no cloud needed',
+        value: 'enterprise',
+        description: 'Business agent with RAG over your company docs, runs 100% on-premise',
+    },
 ];
 const SKILL_PACK_CHOICES = [
     { title: p('Node.js / TypeScript', 24) + 'npm, jest, tsc, eslint', value: 'node' },
@@ -40,7 +45,7 @@ const SKILL_PACK_CHOICES = [
     { title: p('Go', 24) + 'go test, golangci-lint', value: 'go' },
     { title: p('Docker / K8s', 24) + 'docker, kubectl, helm', value: 'docker' },
 ];
-const DEPLOY_MODE_CHOICES = [
+const DEPLOY_MODE_CHOICES_BASE = [
     {
         title: p('Terminal REPL', 28) + 'Humans type requests, agent responds in the terminal',
         value: 'repl',
@@ -63,6 +68,15 @@ const DEPLOY_MODE_CHOICES = [
         value: 'library',
     },
 ];
+const WEB_DEPLOY_CHOICE = {
+    title: p('Web server', 28) + 'WebSocket chat + kanban monitor UI on port 4001',
+    value: 'web',
+    description: 'Serves @backendkit-labs/agent-web with all 6 enterprise departments',
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const deployChoices = (_prev, v) => v.architecture === 'enterprise'
+    ? [...DEPLOY_MODE_CHOICES_BASE, WEB_DEPLOY_CHOICE]
+    : DEPLOY_MODE_CHOICES_BASE;
 const PROVIDER_CHOICES = [
     { title: p('Anthropic (Claude)', 32) + 'claude-sonnet-4-6 recommended', value: 'anthropic' },
     { title: p('OpenAI', 32) + 'gpt-4o recommended', value: 'openai' },
@@ -71,12 +85,14 @@ const PROVIDER_CHOICES = [
 ];
 // ── Conditional question helpers ──────────────────────────────────────────────
 const NEEDS_SKILLS = ['multi-agent', 'single'];
-const NEEDS_DEPLOY = ['multi-agent', 'single', 'coding'];
+const NEEDS_DEPLOY = ['multi-agent', 'single', 'coding', 'enterprise'];
 // @types/prompts doesn't fully type the function form of `type` — cast at call site.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const whenSkills = (_prev, v) => NEEDS_SKILLS.includes(v.architecture) ? 'multiselect' : null;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const whenDeploy = (_prev, v) => NEEDS_DEPLOY.includes(v.architecture) ? 'select' : null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const whenVault = (_prev, v) => v.architecture === 'enterprise' ? 'text' : null;
 // ── Main question flow ────────────────────────────────────────────────────────
 async function askQuestions(defaultName) {
     const raw = await (0, prompts_1.default)([
@@ -108,9 +124,17 @@ async function askQuestions(defaultName) {
             type: whenDeploy,
             name: 'deployMode',
             message: 'How will this agent be used?',
-            choices: DEPLOY_MODE_CHOICES,
+            choices: deployChoices,
             initial: 0,
         },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        {
+            type: whenVault,
+            name: 'vaultPath',
+            message: 'Obsidian vault path (absolute):',
+            initial: '',
+            validate: (v) => v.trim().length > 0 || 'Vault path is required for enterprise agents',
+        },
         {
             type: 'select',
             name: 'provider',
@@ -127,5 +151,6 @@ async function askQuestions(defaultName) {
         skillPacks: (raw.skillPacks ?? []),
         deployMode: (raw.deployMode ?? undefined),
         provider: raw.provider,
+        vaultPath: (raw.vaultPath ?? undefined),
     };
 }

package/dist/src/scaffold.js

@@ -43,7 +43,7 @@ const BASE_DIR = path.join(TEMPLATES_DIR, 'base');
 const DEPLOY_DIR = path.join(TEMPLATES_DIR, 'deploy');
 // Only these architectures use the base + deploy layer pattern.
 // The rest (coding, autonomous, minimal) are self-contained in base/.
-const LAYERED = ['multi-agent', 'single'];
+const LAYERED = ['multi-agent', 'single', 'enterprise'];
 // ── Provider env var hints ────────────────────────────────────────────────────
 const PROVIDER_ENV = {
     anthropic: { varName: 'ANTHROPIC_API_KEY', placeholder: 'sk-ant-...', model: 'claude-sonnet-4-6' },
@@ -77,6 +77,11 @@ const DEPLOY_SCRIPTS = {
         delete s['server'];
     },
     // hybrid: keep both dev (REPL) and server (MCP) — no changes
+    web: (s) => {
+        s['dev'] = 'ts-node src/server.ts';
+        s['start'] = 'node dist/server.js';
+        delete s['server'];
+    },
     library: (s) => {
         delete s['dev'];
         delete s['server'];
@@ -84,6 +89,7 @@ const DEPLOY_SCRIPTS = {
     },
 };
 const MCP_DEPLOY_MODES = ['mcp-http', 'mcp-stdio', 'hybrid'];
+const WEB_DEPLOY_MODES = ['web'];
 function patchPackageJson(dir, projectName, deployMode) {
     const pkgPath = path.join(dir, 'package.json');
     if (!fs.existsSync(pkgPath))
@@ -98,14 +104,27 @@ function patchPackageJson(dir, projectName, deployMode) {
         pkg.dependencies ??= {};
         pkg.dependencies['@backendkit-labs/mcp-server'] ??= '^0.15.0';
     }
+    if (deployMode && WEB_DEPLOY_MODES.includes(deployMode)) {
+        pkg.dependencies ??= {};
+        pkg.dependencies['@backendkit-labs/agent-web'] ??= '^0.1.0';
+    }
     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
 }
 // ── Write .env stub ───────────────────────────────────────────────────────────
-function writeEnv(dir, provider) {
+function writeEnv(dir, provider, choices) {
     const envExample = path.join(dir, '.env.example');
     const envFile = path.join(dir, '.env');
     if (!fs.existsSync(envExample) || fs.existsSync(envFile))
         return;
+    if (choices.architecture === 'enterprise') {
+        // Enterprise uses its own .env.example — just inject VAULT_PATH
+        let content = fs.readFileSync(envExample, 'utf-8');
+        if (choices.vaultPath) {
+            content = content.replace(/^VAULT_PATH=.*/m, `VAULT_PATH=${choices.vaultPath}`);
+        }
+        fs.writeFileSync(envFile, content);
+        return;
+    }
     const p = PROVIDER_ENV[provider];
     const content = [
         '# Generated by create-bk-agent',
@@ -156,10 +175,10 @@ function scaffold(choices, targetDir) {
     // 2. Deploy layer — overlaid on top of base (layered architectures only)
     if (isLayered && choices.deployMode && choices.deployMode !== 'library') {
         const deployDir = path.join(DEPLOY_DIR, choices.deployMode);
-        if (!fs.existsSync(deployDir)) {
-            throw new Error(`Deploy template not found: ${choices.deployMode} (in ${deployDir})`);
+        if (fs.existsSync(deployDir)) {
+            copyDir(deployDir, targetDir);
         }
-        copyDir(deployDir, targetDir);
+        // No directory = base template already covers this mode
     }
     // 3. Skill packs — appended to engine.ts
     for (const pack of choices.skillPacks) {
@@ -168,7 +187,7 @@ function scaffold(choices, targetDir) {
     // 4. Patch package.json (name + deploy-mode script adjustments)
     patchPackageJson(targetDir, choices.projectName, isLayered ? choices.deployMode : undefined);
     // 5. .env stub
-    writeEnv(targetDir, choices.provider);
+    writeEnv(targetDir, choices.provider, choices);
 }
 function installDeps(targetDir) {
     (0, child_process_1.execSync)('npm install', { cwd: targetDir, stdio: 'inherit' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-bk-agent",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Create a new BackendKit agent project",
   "main": "dist/src/index.js",
   "bin": {

package/templates/base/enterprise/.env.example

@@ -0,0 +1,13 @@
+# Enterprise Agent — Local LLM + Knowledge Base
+# Make sure Ollama is running before starting: ollama serve
+# Pull required models: ollama pull llama3.2 && ollama pull nomic-embed-text
+
+# Local LLM (via Ollama)
+OLLAMA_HOST=http://localhost:11434
+OLLAMA_MODEL=llama3.2
+
+# Embeddings model for knowledge base search
+EMBEDDING_MODEL=nomic-embed-text
+
+# Absolute path to your Obsidian vault
+VAULT_PATH=/path/to/your/Obsidian/Vault

package/templates/base/enterprise/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "my-agent",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Enterprise agent with local LLM and Obsidian knowledge base",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "server": "ts-node src/server.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@backendkit-labs/agent-core": "^0.20.0",
+    "@backendkit-labs/agent-coding": "^0.19.2",
+    "@backendkit-labs/agent-enterprise": "^0.2.0",
+    "dotenv": "^16.0.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": { "node": ">=20.0.0" }
+}

package/templates/base/enterprise/src/agents/domain-specialist.ts

@@ -0,0 +1,24 @@
+import type { AgentProfile } from '@backendkit-labs/agent-core';
+
+export const DOMAIN_SPECIALIST_PROFILE: AgentProfile = {
+    id:          'domain-specialist',
+    name:        'Domain Specialist',
+    icon:        '📚',
+    description: 'Answers questions using the company knowledge base',
+    systemPrompt: `You are a specialist with access to the company's knowledge base.
+
+When answering questions:
+1. Use search_knowledge to find relevant information
+2. Base your answer strictly on what you find in the knowledge base
+3. Quote or reference the source when helpful
+4. If information is not found, clearly say "I don't have information about that in the knowledge base"
+5. Never make up information that isn't in the documentation
+6. When you reach a conclusion or discover something useful, use write_knowledge to persist it for future sessions
+
+// TODO: customize this prompt for your specific domain:
+// - HR agent: focus on policies, onboarding, benefits
+// - IT support: focus on troubleshooting guides, procedures
+// - Sales: focus on product catalog, pricing, FAQs`,
+    allowedTools: ['search_knowledge', 'write_knowledge'],
+    delegatesTo:  [],
+};

package/templates/base/enterprise/src/agents/orchestrator.ts

@@ -0,0 +1,20 @@
+import type { AgentProfile } from '@backendkit-labs/agent-core';
+
+export const ORCHESTRATOR_PROFILE: AgentProfile = {
+    id:          'orchestrator',
+    name:        'Orchestrator',
+    icon:        '🎯',
+    description: 'Routes user requests to the right specialist agent',
+    systemPrompt: `You are the main orchestrator for an enterprise knowledge agent.
+Your role is to understand the user's question and route it to the right specialist.
+
+Guidelines:
+- Always delegate to domain-specialist for knowledge base questions
+- Use search_knowledge directly for quick lookups
+- Keep your own responses brief — let specialists do the detailed work
+- If the request is outside the company knowledge base, say so clearly
+
+// TODO: customize routing logic for your specific business domains`,
+    allowedTools: ['search_knowledge', 'ask_agent'],
+    delegatesTo:  ['domain-specialist'],
+};

package/templates/base/enterprise/src/config.ts

@@ -0,0 +1,20 @@
+import 'dotenv/config';
+
+export interface Config {
+    ollamaHost:     string;
+    ollamaModel:    string;
+    embeddingModel: string;
+    vaultPath:      string;
+}
+
+export function loadConfig(): Config {
+    const vaultPath = process.env.VAULT_PATH ?? '';
+    if (!vaultPath) throw new Error('Missing VAULT_PATH in .env — set the absolute path to your Obsidian vault');
+
+    return {
+        ollamaHost:     process.env.OLLAMA_HOST     ?? 'http://localhost:11434',
+        ollamaModel:    process.env.OLLAMA_MODEL    ?? 'llama3.2',
+        embeddingModel: process.env.EMBEDDING_MODEL ?? 'nomic-embed-text',
+        vaultPath,
+    };
+}

package/templates/base/enterprise/src/engine.ts

@@ -0,0 +1,90 @@
+import * as os from 'os';
+import * as path from 'path';
+import {
+    AgentEngine,
+    AgentRegistry,
+    ToolRegistry,
+    ProviderRegistry,
+    CallbackTransport,
+    createMemorySystem,
+} from '@backendkit-labs/agent-core';
+import { OllamaProvider } from '@backendkit-labs/agent-coding';
+import { ObsidianRAGProvider, VaultWriter } from '@backendkit-labs/agent-enterprise';
+import { loadConfig } from './config';
+import { ORCHESTRATOR_PROFILE } from './agents/orchestrator';
+import { DOMAIN_SPECIALIST_PROFILE } from './agents/domain-specialist';
+import { exampleAction } from './tools/example-tools';
+
+// ── Persistent storage paths ──────────────────────────────────────────────────
+
+const APP_DIR = path.join(os.homedir(), '.my-agent');
+const HISTORY = path.join(APP_DIR, 'history.json');
+const MEM_DIR = path.join(APP_DIR, 'memory');
+
+// ── Memory system ─────────────────────────────────────────────────────────────
+
+const memory = createMemorySystem({
+    episodic:   { provider: 'json', path: path.join(MEM_DIR, 'episodes.json') },
+    semantic:   { provider: 'json', path: path.join(MEM_DIR, 'knowledge.json') },
+    procedural: { provider: 'json', path: path.join(MEM_DIR, 'patterns.json') },
+    retention:  { maxEpisodes: 500 },
+});
+
+export function createEngine(transport: CallbackTransport): AgentEngine {
+    const config = loadConfig();
+
+    // ── Knowledge base (RAG) ──────────────────────────────────────────────────
+    // Indexes the Obsidian vault on first use. Subsequent runs are incremental
+    // (only re-embeds new or modified files).
+    const rag = new ObsidianRAGProvider({
+        vaultPath:      config.vaultPath,
+        ollamaHost:     config.ollamaHost,
+        embeddingModel: config.embeddingModel,
+        // TODO: restrict indexing to specific folders:
+        // folders: ['01-Procesos', '02-Politicas', '04-FAQs'],
+    });
+
+    // ── Vault write-back ──────────────────────────────────────────────────────
+    // Agents can contribute new knowledge back to the vault (write_knowledge tool).
+    // Notes land in <vaultPath>/agentes/ and are searchable on next index().
+    const writer = new VaultWriter({ vaultPath: config.vaultPath });
+
+    // ── Tools ─────────────────────────────────────────────────────────────────
+    const tools = new ToolRegistry();
+    tools
+        .register(rag.createTool())              // search_knowledge — semantic search
+        .register(writer.createTool('specialist')) // write_knowledge — agent write-back
+        .register(exampleAction);
+    for (const t of memory.getTools()) tools.register(t);
+    // TODO: register business-specific tools (CRM, ticketing system, internal APIs)
+
+    // ── Agents ────────────────────────────────────────────────────────────────
+    const agents = new AgentRegistry();
+    agents
+        .register(ORCHESTRATOR_PROFILE)
+        .register(DOMAIN_SPECIALIST_PROFILE);
+    // TODO: add more specialists for each business domain
+
+    // ── LLM Provider (local via Ollama) ───────────────────────────────────────
+    const providers = new ProviderRegistry();
+    providers.register('default', new OllamaProvider({
+        host:  config.ollamaHost,
+        model: config.ollamaModel,
+    }));
+
+    return new AgentEngine({
+        model:              { provider: 'default', id: config.ollamaModel },
+        agents,
+        tools,
+        providers,
+        defaultProvider:    'default',
+        defaultAgentId:     'orchestrator',
+        transport,
+        maxIterations:      30,
+        iterationMode:      'auto',
+        historyPath:        HISTORY,
+        maxContextMessages: 100,
+        memorySystem:       memory,
+        additionalRoots:    [APP_DIR],
+    });
+}

package/templates/base/enterprise/src/tools/example-tools.ts

@@ -0,0 +1,19 @@
+import { defineTool, z } from '@backendkit-labs/agent-core';
+
+// Example tool — replace with tools that connect to your business systems
+// e.g. CRM lookup, ticketing system, internal APIs, databases
+
+export const exampleAction = defineTool({
+    name:        'create_ticket',
+    description: 'Creates a support ticket in the ticketing system (example — replace with your integration)',
+    input: z.object({
+        title:    z.string().describe('Short description of the issue'),
+        priority: z.enum(['low', 'medium', 'high']).describe('Ticket priority'),
+        details:  z.string().optional().describe('Additional details'),
+    }),
+    execute: async ({ title, priority, details }) => {
+        // TODO: integrate with your ticketing system (Jira, ServiceNow, Linear, etc.)
+        const id = `TICKET-${Date.now()}`;
+        return `Ticket created: ${id} — "${title}" [${priority}]${details ? `\nDetails: ${details}` : ''}`;
+    },
+});

package/templates/base/enterprise/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}