javi-forge 0.1.0 → 1.0.0

package/dist/constants.d.ts

@@ -14,6 +14,14 @@ export declare const SCHEMAS_DIR: string;
 export declare const CI_LOCAL_DIR: string;
 /** Dependabot fragment directory */
 export declare const DEPENDABOT_FRAGMENTS_DIR: string;
+/** Plugins directory (installed plugins) */
+export declare const PLUGINS_DIR: string;
+/** Plugin registry URL */
+export declare const PLUGIN_REGISTRY_URL = "https://raw.githubusercontent.com/JNZader/javi-forge-registry/main/registry.json";
+/** Plugin manifest filename */
+export declare const PLUGIN_MANIFEST_FILE = "plugin.json";
+/** Valid plugin asset directories */
+export declare const PLUGIN_ASSET_DIRS: readonly ["skills", "commands", "hooks", "agents"];
 /** Stack-to-dependabot fragment mapping */
 export declare const STACK_DEPENDABOT_MAP: Record<string, string[]>;
 /** Stack-to-CI template filename mapping */

package/dist/constants.js

@@ -17,6 +17,14 @@ export const SCHEMAS_DIR = path.join(FORGE_ROOT, 'schemas');
 export const CI_LOCAL_DIR = path.join(FORGE_ROOT, 'ci-local');
 /** Dependabot fragment directory */
 export const DEPENDABOT_FRAGMENTS_DIR = path.join(TEMPLATES_DIR, 'common', 'dependabot');
+/** Plugins directory (installed plugins) */
+export const PLUGINS_DIR = path.join(FORGE_ROOT, 'plugins');
+/** Plugin registry URL */
+export const PLUGIN_REGISTRY_URL = 'https://raw.githubusercontent.com/JNZader/javi-forge-registry/main/registry.json';
+/** Plugin manifest filename */
+export const PLUGIN_MANIFEST_FILE = 'plugin.json';
+/** Valid plugin asset directories */
+export const PLUGIN_ASSET_DIRS = ['skills', 'commands', 'hooks', 'agents'];
 /** Stack-to-dependabot fragment mapping */
 export const STACK_DEPENDABOT_MAP = {
     'node': ['npm'],

package/dist/index.js

@@ -5,15 +5,23 @@ import meow from 'meow';
 import App from './ui/App.js';
 import Doctor from './ui/Doctor.js';
 import AnalyzeUI from './ui/AnalyzeUI.js';
+import Plugin from './ui/Plugin.js';
+import LlmsTxt from './ui/LlmsTxt.js';
 import { CIProvider as CIContextProvider } from './ui/CIContext.js';
 const cli = meow(`
   Usage
     $ javi-forge [command] [options]
 
   Commands
-    init        Bootstrap a new project (default)
-    analyze     Run repoforge skills analysis
-    doctor      Show health report
+    init              Bootstrap a new project (default)
+    analyze           Run repoforge skills analysis
+    doctor            Show health report
+    plugin add        Install a plugin from GitHub (org/repo)
+    plugin remove     Remove an installed plugin
+    plugin list       List installed plugins
+    plugin search     Search the plugin registry
+    plugin validate   Validate a local plugin directory
+    llms-txt          Generate AI-friendly llms.txt for current project
 
   Options
     --dry-run       Preview changes without writing files
@@ -22,6 +30,7 @@ const cli = meow(`
     --memory        Memory module (engram, obsidian-brain, memory-simple, none)
     --project-name  Project name (skips name prompt)
     --ghagga        Enable GHAGGA review system
+    --mock          Enable mock-first mode (no real API keys needed)
     --batch         Non-interactive mode (auto-proceed, no keyboard input)
     --version       Show version
     --help          Show this help
@@ -34,6 +43,11 @@ const cli = meow(`
     $ javi-forge analyze
     $ javi-forge analyze --dry-run
     $ javi-forge doctor
+    $ javi-forge plugin add mapbox/agent-skills
+    $ javi-forge plugin list
+    $ javi-forge plugin search ai
+    $ javi-forge plugin validate ./my-plugin
+    $ javi-forge plugin remove my-plugin
 `, {
     importMeta: import.meta,
     flags: {
@@ -43,6 +57,7 @@ const cli = meow(`
         memory: { type: 'string', default: '' },
         projectName: { type: 'string', default: '' },
         ghagga: { type: 'boolean', default: false },
+        mock: { type: 'boolean', default: false },
         batch: { type: 'boolean', default: false },
     }
 });
@@ -62,6 +77,20 @@ switch (subcommand) {
             React.createElement(AnalyzeUI, { dryRun: cli.flags.dryRun })));
         break;
     }
+    case 'llms-txt': {
+        render(React.createElement(CIContextProvider, { isCI: isCI },
+            React.createElement(LlmsTxt, { projectDir: process.cwd(), dryRun: cli.flags.dryRun })));
+        break;
+    }
+    case 'plugin': {
+        const pluginAction = cli.input[1];
+        const VALID_PLUGIN_ACTIONS = ['add', 'remove', 'list', 'search', 'validate'];
+        const action = pluginAction && VALID_PLUGIN_ACTIONS.includes(pluginAction) ? pluginAction : 'list';
+        const target = cli.input[2];
+        render(React.createElement(CIContextProvider, { isCI: isCI },
+            React.createElement(Plugin, { action: action, target: target, dryRun: cli.flags.dryRun })));
+        break;
+    }
     case 'init':
     default: {
         const presetStack = VALID_STACKS.includes(cli.flags.stack)
@@ -75,7 +104,7 @@ switch (subcommand) {
             : undefined;
         const presetName = cli.flags.projectName || undefined;
         render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(App, { dryRun: cli.flags.dryRun, presetStack: presetStack, presetCI: presetCI, presetMemory: presetMemory, presetName: presetName, presetGhagga: cli.flags.ghagga })));
+            React.createElement(App, { dryRun: cli.flags.dryRun, presetStack: presetStack, presetCI: presetCI, presetMemory: presetMemory, presetName: presetName, presetGhagga: cli.flags.ghagga, presetMock: cli.flags.mock ?? false })));
         break;
     }
 }

package/dist/lib/plugin.d.ts

@@ -0,0 +1,39 @@
+import type { PluginValidationResult, InstalledPlugin, PluginRegistryEntry } from '../types/index.js';
+/**
+ * Validate a plugin directory structure and manifest.
+ */
+export declare function validatePlugin(pluginDir: string): Promise<PluginValidationResult>;
+/**
+ * Install a plugin from a GitHub repository.
+ * Clones the repo to a temp dir, validates, then copies to plugins dir.
+ */
+export declare function installPlugin(source: string, options?: {
+    dryRun?: boolean;
+}): Promise<{
+    success: boolean;
+    name?: string;
+    error?: string;
+}>;
+/**
+ * Remove an installed plugin by name.
+ */
+export declare function removePlugin(name: string, options?: {
+    dryRun?: boolean;
+}): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * List all installed plugins.
+ */
+export declare function listInstalledPlugins(): Promise<InstalledPlugin[]>;
+/**
+ * Fetch the remote plugin registry and optionally filter by query.
+ */
+export declare function searchRegistry(query?: string): Promise<PluginRegistryEntry[]>;
+/**
+ * Normalize a GitHub source to a git clone URL.
+ * Accepts: "org/repo", "https://github.com/org/repo", "github.com/org/repo"
+ */
+export declare function normalizeGitUrl(source: string): string | null;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/lib/plugin.js

@@ -0,0 +1,228 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { PLUGINS_DIR, PLUGIN_MANIFEST_FILE, PLUGIN_ASSET_DIRS, PLUGIN_REGISTRY_URL } from '../constants.js';
+const execFileAsync = promisify(execFile);
+const KEBAB_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+// ── Validation ──────────────────────────────────────────────────────────────
+/**
+ * Validate a plugin directory structure and manifest.
+ */
+export async function validatePlugin(pluginDir) {
+    const errors = [];
+    // Check plugin.json exists
+    const manifestPath = path.join(pluginDir, PLUGIN_MANIFEST_FILE);
+    if (!await fs.pathExists(manifestPath)) {
+        return {
+            valid: false,
+            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'plugin.json not found' }],
+            manifest: null,
+        };
+    }
+    // Parse manifest
+    let manifest;
+    try {
+        manifest = await fs.readJson(manifestPath);
+    }
+    catch {
+        return {
+            valid: false,
+            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'invalid JSON' }],
+            manifest: null,
+        };
+    }
+    // Validate required fields
+    if (typeof manifest.name !== 'string' || !manifest.name) {
+        errors.push({ path: 'name', message: 'name is required' });
+    }
+    else if (!KEBAB_RE.test(manifest.name)) {
+        errors.push({ path: 'name', message: 'name must be kebab-case' });
+    }
+    else if (manifest.name.length < 2 || manifest.name.length > 60) {
+        errors.push({ path: 'name', message: 'name must be 2-60 characters' });
+    }
+    if (typeof manifest.version !== 'string' || !manifest.version) {
+        errors.push({ path: 'version', message: 'version is required' });
+    }
+    else if (!SEMVER_RE.test(manifest.version)) {
+        errors.push({ path: 'version', message: 'version must be semver (e.g. 1.0.0)' });
+    }
+    if (typeof manifest.description !== 'string' || !manifest.description) {
+        errors.push({ path: 'description', message: 'description is required' });
+    }
+    else if (manifest.description.length < 10) {
+        errors.push({ path: 'description', message: 'description must be at least 10 characters' });
+    }
+    else if (manifest.description.length > 200) {
+        errors.push({ path: 'description', message: 'description must be at most 200 characters' });
+    }
+    // Validate asset directories actually exist when declared
+    for (const assetType of PLUGIN_ASSET_DIRS) {
+        const declared = manifest[assetType];
+        if (!Array.isArray(declared) || declared.length === 0)
+            continue;
+        const assetDir = path.join(pluginDir, assetType);
+        if (!await fs.pathExists(assetDir)) {
+            errors.push({ path: assetType, message: `declared ${assetType}/ directory not found` });
+            continue;
+        }
+        // Check each declared asset exists
+        for (const entry of declared) {
+            const entryPath = path.join(assetDir, entry);
+            if (!await fs.pathExists(entryPath)) {
+                errors.push({ path: `${assetType}/${entry}`, message: `declared entry not found` });
+            }
+        }
+    }
+    // Validate tags
+    if (manifest.tags && !Array.isArray(manifest.tags)) {
+        errors.push({ path: 'tags', message: 'tags must be an array' });
+    }
+    else if (manifest.tags && manifest.tags.length > 10) {
+        errors.push({ path: 'tags', message: 'max 10 tags allowed' });
+    }
+    return { valid: errors.length === 0, errors, manifest: errors.length === 0 ? manifest : manifest };
+}
+// ── Installation ────────────────────────────────────────────────────────────
+/**
+ * Install a plugin from a GitHub repository.
+ * Clones the repo to a temp dir, validates, then copies to plugins dir.
+ */
+export async function installPlugin(source, options = {}) {
+    const { dryRun = false } = options;
+    // Normalize source to a git URL
+    const gitUrl = normalizeGitUrl(source);
+    if (!gitUrl) {
+        return { success: false, error: `invalid source: ${source}. Use org/repo or a GitHub URL` };
+    }
+    // Clone to temp
+    const tmpDir = path.join(PLUGINS_DIR, '.tmp', `install-${Date.now()}`);
+    try {
+        if (!dryRun) {
+            await fs.ensureDir(tmpDir);
+            await execFileAsync('git', ['clone', '--depth', '1', gitUrl, tmpDir], {
+                timeout: 60_000,
+            });
+        }
+        // Validate
+        const validation = dryRun
+            ? { valid: true, errors: [], manifest: { name: source.split('/').pop() ?? 'unknown', version: '0.0.0', description: 'dry-run placeholder' } }
+            : await validatePlugin(tmpDir);
+        if (!validation.valid || !validation.manifest) {
+            const msgs = validation.errors.map(e => `  ${e.path}: ${e.message}`).join('\n');
+            return { success: false, error: `validation failed:\n${msgs}` };
+        }
+        const pluginName = validation.manifest.name;
+        const destDir = path.join(PLUGINS_DIR, pluginName);
+        if (!dryRun) {
+            // Remove existing version if present
+            if (await fs.pathExists(destDir)) {
+                await fs.remove(destDir);
+            }
+            await fs.move(tmpDir, destDir);
+            // Write install metadata
+            const installedPlugin = {
+                name: pluginName,
+                version: validation.manifest.version,
+                installedAt: new Date().toISOString(),
+                source,
+                manifest: validation.manifest,
+            };
+            await fs.writeJson(path.join(destDir, '.installed.json'), installedPlugin, { spaces: 2 });
+        }
+        return { success: true, name: pluginName };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { success: false, error: msg };
+    }
+    finally {
+        // Clean up tmp if it still exists (error path)
+        if (!dryRun && await fs.pathExists(tmpDir)) {
+            await fs.remove(tmpDir).catch(() => { });
+        }
+    }
+}
+/**
+ * Remove an installed plugin by name.
+ */
+export async function removePlugin(name, options = {}) {
+    const pluginDir = path.join(PLUGINS_DIR, name);
+    if (!await fs.pathExists(pluginDir)) {
+        return { success: false, error: `plugin "${name}" is not installed` };
+    }
+    if (!options.dryRun) {
+        await fs.remove(pluginDir);
+    }
+    return { success: true };
+}
+// ── Listing & Search ────────────────────────────────────────────────────────
+/**
+ * List all installed plugins.
+ */
+export async function listInstalledPlugins() {
+    if (!await fs.pathExists(PLUGINS_DIR))
+        return [];
+    const entries = await fs.readdir(PLUGINS_DIR);
+    const plugins = [];
+    for (const entry of entries) {
+        if (entry.startsWith('.'))
+            continue;
+        const metaPath = path.join(PLUGINS_DIR, entry, '.installed.json');
+        if (await fs.pathExists(metaPath)) {
+            try {
+                const meta = await fs.readJson(metaPath);
+                plugins.push(meta);
+            }
+            catch { /* skip corrupt entries */ }
+        }
+    }
+    return plugins;
+}
+/**
+ * Fetch the remote plugin registry and optionally filter by query.
+ */
+export async function searchRegistry(query) {
+    try {
+        const response = await fetch(PLUGIN_REGISTRY_URL);
+        if (!response.ok) {
+            return [];
+        }
+        const registry = await response.json();
+        let plugins = registry.plugins ?? [];
+        if (query) {
+            const q = query.toLowerCase();
+            plugins = plugins.filter(p => p.id.toLowerCase().includes(q) ||
+                p.description.toLowerCase().includes(q) ||
+                p.tags.some(t => t.toLowerCase().includes(q)));
+        }
+        return plugins;
+    }
+    catch {
+        return [];
+    }
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Normalize a GitHub source to a git clone URL.
+ * Accepts: "org/repo", "https://github.com/org/repo", "github.com/org/repo"
+ */
+export function normalizeGitUrl(source) {
+    // Already a full URL
+    if (source.startsWith('https://github.com/')) {
+        return source.endsWith('.git') ? source : `${source}.git`;
+    }
+    // github.com/org/repo
+    if (source.startsWith('github.com/')) {
+        return `https://${source}.git`;
+    }
+    // org/repo shorthand
+    const parts = source.split('/');
+    if (parts.length === 2 && parts[0] && parts[1]) {
+        return `https://github.com/${parts[0]}/${parts[1]}.git`;
+    }
+    return null;
+}
+//# sourceMappingURL=plugin.js.map

package/dist/lib/plugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin.test.d.ts.map

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export interface InitOptions {
     aiSync: boolean;
     sdd: boolean;
     ghagga: boolean;
+    mock: boolean;
     dryRun: boolean;
 }
 export interface InitStep {
@@ -45,4 +46,45 @@ export interface DoctorSection {
 export interface DoctorResult {
     sections: DoctorSection[];
 }
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    author?: string;
+    repository?: string;
+    skills?: string[];
+    commands?: string[];
+    hooks?: string[];
+    agents?: string[];
+    tags?: string[];
+}
+export interface PluginRegistryEntry {
+    id: string;
+    repository: string;
+    description: string;
+    tags: string[];
+    stars?: number;
+    updatedAt?: string;
+}
+export interface PluginRegistry {
+    version: string;
+    updatedAt: string;
+    plugins: PluginRegistryEntry[];
+}
+export interface PluginValidationError {
+    path: string;
+    message: string;
+}
+export interface PluginValidationResult {
+    valid: boolean;
+    errors: PluginValidationError[];
+    manifest: PluginManifest | null;
+}
+export interface InstalledPlugin {
+    name: string;
+    version: string;
+    installedAt: string;
+    source: string;
+    manifest: PluginManifest;
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/ui/App.d.ts

@@ -7,7 +7,8 @@ interface AppProps {
     presetMemory?: MemoryOption;
     presetName?: string;
     presetGhagga?: boolean;
+    presetMock?: boolean;
 }
-export default function App({ dryRun, presetStack, presetCI, presetMemory, presetName, presetGhagga, }: AppProps): React.JSX.Element;
+export default function App({ dryRun, presetStack, presetCI, presetMemory, presetName, presetGhagga, presetMock, }: AppProps): React.JSX.Element;
 export {};
 //# sourceMappingURL=App.d.ts.map

package/dist/ui/App.js

@@ -11,7 +11,7 @@ import OptionSelector from './OptionSelector.js';
 import Progress from './Progress.js';
 import Summary from './Summary.js';
 import { initProject } from '../commands/init.js';
-export default function App({ dryRun = false, presetStack, presetCI, presetMemory, presetName, presetGhagga = false, }) {
+export default function App({ dryRun = false, presetStack, presetCI, presetMemory, presetName, presetGhagga = false, presetMock = false, }) {
     const [stage, setStage] = useState('welcome');
     const [projectName, setProjectName] = useState(presetName ?? '');
     const [projectDir, setProjectDir] = useState(presetName ? path.resolve(process.cwd(), presetName) : '');
@@ -54,6 +54,7 @@ export default function App({ dryRun = false, presetStack, presetCI, presetMemor
             aiSync: opts.aiSync,
             sdd: opts.sdd,
             ghagga: opts.ghagga,
+            mock: presetMock,
             dryRun,
         }, (step) => setSteps(prev => {
             const idx = prev.findIndex(s => s.id === step.id);

package/dist/ui/LlmsTxt.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface Props {
+    projectDir: string;
+    dryRun: boolean;
+}
+export default function LlmsTxt({ projectDir, dryRun }: Props): React.JSX.Element;
+export {};
+//# sourceMappingURL=LlmsTxt.d.ts.map

package/dist/ui/LlmsTxt.js

@@ -0,0 +1,48 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { generateLlmsTxt } from '../commands/llmstxt.js';
+import { theme } from './theme.js';
+const STATUS_ICON = {
+    done: '\u2713', error: '\u2717', skipped: '\u2013',
+};
+export default function LlmsTxt({ projectDir, dryRun }) {
+    const [steps, setSteps] = useState([]);
+    const [done, setDone] = useState(false);
+    const onStep = (step) => {
+        setSteps(prev => {
+            const idx = prev.findIndex(s => s.id === step.id);
+            if (idx >= 0) {
+                const n = [...prev];
+                n[idx] = step;
+                return n;
+            }
+            return [...prev, step];
+        });
+    };
+    useEffect(() => {
+        generateLlmsTxt(projectDir, dryRun, onStep)
+            .catch(e => onStep({ id: 'fatal', label: 'Error', status: 'error', detail: String(e) }))
+            .finally(() => setDone(true));
+    }, [projectDir, dryRun]);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: theme.primary }, "javi-forge"),
+            React.createElement(Text, null, " llms-txt"),
+            dryRun && React.createElement(Text, { color: theme.warning }, " (dry-run)")),
+        steps.map(s => (React.createElement(Box, { key: s.id, marginLeft: 2 }, s.status === 'running'
+            ? React.createElement(Text, { color: theme.warning },
+                React.createElement(Spinner, { type: "dots" }),
+                " ",
+                s.label)
+            : React.createElement(Text, { color: s.status === 'done' ? theme.success : s.status === 'error' ? theme.error : theme.muted },
+                STATUS_ICON[s.status],
+                " ",
+                s.label,
+                s.detail ? React.createElement(Text, { color: theme.muted, dimColor: true },
+                    "  ",
+                    s.detail) : null)))),
+        done && React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: theme.muted }, "Done."))));
+}
+//# sourceMappingURL=LlmsTxt.js.map

package/dist/ui/Plugin.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface PluginProps {
+    action: 'add' | 'remove' | 'list' | 'search' | 'validate';
+    target?: string;
+    dryRun: boolean;
+}
+export default function Plugin({ action, target, dryRun }: PluginProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/ui/Plugin.js

@@ -0,0 +1,96 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { runPluginAdd, runPluginRemove, runPluginList, runPluginSearch, runPluginValidate } from '../commands/plugin.js';
+import { theme } from './theme.js';
+const STATUS_ICON = {
+    pending: '\u25cb',
+    done: '\u2713',
+    error: '\u2717',
+    skipped: '\u2013',
+};
+const STATUS_COLOR = {
+    pending: theme.muted,
+    running: theme.warning,
+    done: theme.success,
+    error: theme.error,
+    skipped: theme.muted,
+};
+export default function Plugin({ action, target, dryRun }) {
+    const [steps, setSteps] = useState([]);
+    const [done, setDone] = useState(false);
+    const onStep = (step) => {
+        setSteps(prev => {
+            const idx = prev.findIndex(s => s.id === step.id);
+            if (idx >= 0) {
+                const next = [...prev];
+                next[idx] = step;
+                return next;
+            }
+            return [...prev, step];
+        });
+    };
+    useEffect(() => {
+        const run = async () => {
+            try {
+                switch (action) {
+                    case 'add':
+                        if (!target) {
+                            onStep({ id: 'err', label: 'Error', status: 'error', detail: 'source required: javi-forge plugin add <org/repo>' });
+                            break;
+                        }
+                        await runPluginAdd(target, dryRun, onStep);
+                        break;
+                    case 'remove':
+                        if (!target) {
+                            onStep({ id: 'err', label: 'Error', status: 'error', detail: 'name required: javi-forge plugin remove <name>' });
+                            break;
+                        }
+                        await runPluginRemove(target, dryRun, onStep);
+                        break;
+                    case 'list':
+                        await runPluginList(onStep);
+                        break;
+                    case 'search':
+                        await runPluginSearch(target, onStep);
+                        break;
+                    case 'validate':
+                        if (!target) {
+                            onStep({ id: 'err', label: 'Error', status: 'error', detail: 'path required: javi-forge plugin validate <dir>' });
+                            break;
+                        }
+                        await runPluginValidate(target, onStep);
+                        break;
+                }
+            }
+            catch (e) {
+                onStep({ id: 'fatal', label: 'Fatal error', status: 'error', detail: String(e) });
+            }
+            setDone(true);
+        };
+        run();
+    }, [action, target, dryRun]);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: theme.primary }, "javi-forge"),
+            React.createElement(Text, null,
+                " plugin ",
+                action),
+            dryRun && React.createElement(Text, { color: theme.warning }, " (dry-run)")),
+        steps.map(step => (React.createElement(Box, { key: step.id, marginLeft: 2 }, step.status === 'running' ? (React.createElement(Text, { color: theme.warning },
+            React.createElement(Spinner, { type: "dots" }),
+            ' ',
+            step.label,
+            step.detail ? React.createElement(Text, { color: theme.muted, dimColor: true },
+                "  ",
+                step.detail) : null)) : (React.createElement(Text, { color: STATUS_COLOR[step.status] },
+            STATUS_ICON[step.status],
+            " ",
+            step.label,
+            step.detail ? React.createElement(Text, { color: theme.muted, dimColor: true },
+                "  ",
+                step.detail) : null))))),
+        done && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: theme.muted }, "Done.")))));
+}
+//# sourceMappingURL=Plugin.js.map

package/modules/obsidian-brain/README.md

@@ -266,3 +266,35 @@ Si ya usas vibekanban:
 3. Agregar frontmatter YAML a archivos existentes (CONTEXT, DECISIONS, etc.)
 4. Agregar inline fields Dataview a ADRs y blockers existentes
 5. Actualizar `.gitignore` con el snippet de Obsidian
+
+## Role-Based Templates
+
+Obsidian Brain includes role-based templates organized by persona, sourced from vault/Javi.Dots:
+
+### Core Templates (`core/templates/`)
+| Template | Purpose |
+|----------|---------|
+| `daily-note.md` | Daily focus, notes, reflections |
+| `braindump.md` | Quick unstructured idea capture |
+| `consolidation.md` | Weekly knowledge consolidation |
+| `resource-capture.md` | Annotated resource bookmarking |
+
+### Developer Templates (`developer/templates/`)
+| Template | Purpose |
+|----------|---------|
+| `coding-session.md` | Goal, work log, blockers, decisions, next steps |
+| `adr.md` | Architecture Decision Record with decision map |
+| `debug-journal.md` | Structured debugging sessions |
+| `sdd-feedback.md` | Spec-Driven Development feedback |
+| `tech-debt.md` | Technical debt tracking |
+
+### PM/Lead Templates (`pm-lead/templates/`)
+| Template | Purpose |
+|----------|---------|
+| `daily-brief.md` | Daily standup summary |
+| `weekly-brief.md` | Weekly progress report |
+| `sprint-review.md` | Sprint retrospective |
+| `meeting-notes.md` | Structured meeting notes |
+| `risk-registry.md` | Risk tracking and mitigation |
+| `stakeholder-update.md` | Stakeholder communication |
+| `team-intelligence.md` | Team performance patterns |