@christianmaf80/agentic-workflow 1.2.0-beta.1

package/dist/cli/commands/mcp-register.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCorePath, resolveInstalledCorePath } from '../../core/mapping/resolver.js';
+export async function registerMcpCommand(options) {
+    if (!options.path) {
+        throw new Error('Missing --path. Provide the full path to the MCP config file.');
+    }
+    const configPath = options.path;
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    const config = await readConfig(configPath);
+    config.mcpServers = config.mcpServers ?? {};
+    const corePath = (await resolveInstalledCorePath(process.cwd())) ?? await resolveCorePath();
+    const binPath = path.join(corePath, '../bin/cli.js');
+    config.mcpServers['agentic-workflow'] = {
+        command: 'node',
+        args: [binPath, 'mcp'],
+        env: {},
+        disabled: false
+    };
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    // eslint-disable-next-line no-console
+    console.log(`MCP server registered at: ${configPath}`);
+}
+async function readConfig(configPath) {
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/cli/commands/restore.js

@@ -0,0 +1,67 @@
+import { intro, outro, spinner, select, confirm } from '@clack/prompts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function restoreCommand() {
+    intro('Agentic Workflow Recovery');
+    const cwd = process.cwd();
+    const backupBaseDir = path.join(cwd, '.agent-backups');
+    try {
+        await fs.access(backupBaseDir);
+    }
+    catch {
+        outro('No backups were found in .agent-backups/');
+        return;
+    }
+    const backups = await fs.readdir(backupBaseDir);
+    if (backups.length === 0) {
+        outro('No backups available.');
+        return;
+    }
+    // Sort backups by date (newest first)
+    const sortedBackups = backups.sort((a, b) => b.localeCompare(a));
+    const selectedBackup = await select({
+        message: 'Select the backup you want to restore:',
+        options: sortedBackups.map(b => ({ value: b, label: b })),
+    });
+    if (typeof selectedBackup === 'symbol') {
+        outro('Operation cancelled.');
+        return;
+    }
+    const shouldRestore = await confirm({
+        message: `Are you sure you want to restore the backup "${selectedBackup}"? The current .agent/ folder will be overwritten.`,
+    });
+    if (!shouldRestore || typeof shouldRestore === 'symbol') {
+        outro('Restoration cancelled.');
+        return;
+    }
+    const s = spinner();
+    s.start('Restoring backup...');
+    const backupPath = path.join(backupBaseDir, selectedBackup, '.agent');
+    const targetPath = path.join(cwd, '.agent');
+    try {
+        // Simple strategy: delete current and copy backup
+        await fs.rm(targetPath, { recursive: true, force: true });
+        await copyRecursive(backupPath, targetPath);
+        s.stop('Restoration complete.');
+        outro(`The system has been successfully restored from ${selectedBackup}`);
+    }
+    catch (error) {
+        s.stop('Restoration failed.');
+        console.error(error);
+        outro('Error during restoration.');
+    }
+}
+async function copyRecursive(src, dest) {
+    const stats = await fs.stat(src);
+    const isDirectory = stats.isDirectory();
+    if (isDirectory) {
+        await fs.mkdir(dest, { recursive: true });
+        const files = await fs.readdir(src);
+        for (const file of files) {
+            await copyRecursive(path.join(src, file), path.join(dest, file));
+        }
+    }
+    else {
+        await fs.copyFile(src, dest);
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export * from './commands/init.js';
+export * from './commands/create.js';

package/dist/core/context/manager.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class ContextManager {
+    projectRoot;
+    corePath;
+    constructor(projectRoot, corePath) {
+        this.projectRoot = projectRoot;
+        this.corePath = corePath;
+    }
+    /**
+     * Resuelve un alias (ej: 'rules.constitution') a un conjunto de ficheros.
+     */
+    async resolveAlias(aliasPath) {
+        const parts = aliasPath.split('.');
+        let currentPath = path.join(this.projectRoot, '.agent/index.md');
+        let currentContext = null;
+        // Si el alias empieza por 'agent.core', saltamos al core
+        if (aliasPath.startsWith('agent.core')) {
+            currentPath = path.join(this.corePath, 'index.md');
+        }
+        const files = [];
+        // Esta es una implementación simplificada que busca en los índices conocidos
+        // Para una implementación completa, se requeriría un crawler de YAML
+        if (aliasPath.includes('constitution')) {
+            const constitutions = ['GEMINI.location.md', 'project-architecture.md', 'clean-code.md', 'agent-system.md'];
+            for (const c of constitutions) {
+                const p = path.join(this.corePath, 'rules/constitution', c);
+                if (await this.exists(p)) {
+                    files.push(await this.readFile(p, `constitution.${c.replace('.md', '')}`));
+                }
+            }
+        }
+        else if (aliasPath.includes('roles')) {
+            const rolesDir = path.join(this.corePath, 'rules/roles');
+            const roleFiles = await fs.readdir(rolesDir);
+            for (const f of roleFiles) {
+                if (f.endsWith('.md') && f !== 'index.md') {
+                    files.push(await this.readFile(path.join(rolesDir, f), `roles.${f.replace('.md', '')}`));
+                }
+            }
+        }
+        return files;
+    }
+    /**
+     * Crea un bundle de inicialización (Bootstrap) siguiendo las Best Practices.
+     */
+    async bootstrapContext() {
+        const files = [];
+        // 1. Índice Maestro Local
+        const localIndex = path.join(this.projectRoot, '.agent/index.md');
+        files.push(await this.readFile(localIndex, 'agent.index'));
+        // 2. Local Domain Indexes (client-defined)
+        const localRulesIndex = path.join(this.projectRoot, '.agent/rules/index.md');
+        const localRolesIndex = path.join(this.projectRoot, '.agent/rules/roles/index.md');
+        const localWorkflowsIndex = path.join(this.projectRoot, '.agent/workflows/index.md');
+        const localArtifactsIndex = path.join(this.projectRoot, '.agent/artifacts/index.md');
+        const localTemplatesIndex = path.join(this.projectRoot, '.agent/templates/index.md');
+        if (await this.exists(localRulesIndex))
+            files.push(await this.readFile(localRulesIndex, 'agent.local.rules'));
+        if (await this.exists(localRolesIndex))
+            files.push(await this.readFile(localRolesIndex, 'agent.local.roles'));
+        if (await this.exists(localWorkflowsIndex))
+            files.push(await this.readFile(localWorkflowsIndex, 'agent.local.workflows'));
+        if (await this.exists(localArtifactsIndex))
+            files.push(await this.readFile(localArtifactsIndex, 'agent.local.artifacts'));
+        if (await this.exists(localTemplatesIndex))
+            files.push(await this.readFile(localTemplatesIndex, 'agent.local.templates'));
+        // 3. Índices del Core
+        const coreRulesIndex = path.join(this.corePath, 'rules/index.md');
+        const coreWorkflowsIndex = path.join(this.corePath, 'workflows/index.md');
+        const coreTemplatesIndex = path.join(this.corePath, 'templates/index.md');
+        const coreArtifactsIndex = path.join(this.corePath, 'artifacts/index.md');
+        if (await this.exists(coreRulesIndex))
+            files.push(await this.readFile(coreRulesIndex, 'agent.core.rules'));
+        if (await this.exists(coreWorkflowsIndex))
+            files.push(await this.readFile(coreWorkflowsIndex, 'agent.core.workflows'));
+        if (await this.exists(coreTemplatesIndex))
+            files.push(await this.readFile(coreTemplatesIndex, 'agent.core.templates'));
+        if (await this.exists(coreArtifactsIndex))
+            files.push(await this.readFile(coreArtifactsIndex, 'agent.core.artifacts'));
+        // 4. Constituciones Críticas
+        const constitutions = ['GEMINI.location.md', 'project-architecture.md', 'clean-code.md', 'agent-system.md'];
+        for (const c of constitutions) {
+            const p = path.join(this.corePath, 'rules/constitution', c);
+            if (await this.exists(p)) {
+                files.push(await this.readFile(p, `constitution.${c.replace('.md', '')}`));
+            }
+        }
+        // 5. Rol Arquitecto
+        const archRole = path.join(this.corePath, 'rules/roles/architect.md');
+        if (await this.exists(archRole)) {
+            files.push(await this.readFile(archRole, 'roles.architect'));
+        }
+        return this.formatBundle(files, true);
+    }
+    async readFile(filePath, alias) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return { path: filePath, content, alias };
+    }
+    async exists(p) {
+        try {
+            await fs.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    formatBundle(files, isBootstrap = false) {
+        let bundle = isBootstrap ? "# BOOTSTRAP CONTEXT BUNDLE\n\n" : "# CONTEXT BUNDLE\n\n";
+        // 1. Manifiesto de Carga (Best Practice)
+        bundle += "## MANIFIESTO DE CARGA\n";
+        bundle += "Este bundle contiene los siguientes dominios de contexto:\n";
+        for (const file of files) {
+            bundle += `- [x] \`${file.alias || path.basename(file.path)}\` (v1.0)\n`;
+        }
+        bundle += "\n---\n\n";
+        for (const file of files) {
+            bundle += `## FILE: ${file.alias || file.path}\n`;
+            bundle += `Path: \`file://${file.path}\`\n\n`;
+            bundle += "```markdown\n";
+            bundle += file.content;
+            if (!file.content.endsWith('\n'))
+                bundle += '\n';
+            bundle += "```\n\n---\n\n";
+        }
+        // 2. Siguientes Pasos / Discovery (Best Practice)
+        if (isBootstrap) {
+            bundle += "## SIGUIENTES PASOS (DISCOVERY)\n";
+            bundle += "El sistema está inicializado. Puedes profundizar en dominios específicos usando:\n";
+            bundle += "- `tool: hydrate_context({ alias: \"agent.core.rules\" })` para cargar todas las reglas.\n";
+            bundle += "- `tool: hydrate_context({ alias: \"agent.core.workflows\" })` para ver procesos disponibles.\n";
+        }
+        return bundle;
+    }
+}

package/dist/core/index.js

@@ -0,0 +1 @@
+export const AGENT_ROOT = '.agent';

package/dist/core/mapping/resolver.js

@@ -0,0 +1,72 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+/**
+ * Resuelve la ruta absoluta del core del framework agentic-workflow.
+ * Busca las carpetas 'rules', 'workflows' y 'templates' desde la ubicación del script.
+ */
+export async function resolveCorePath() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // Intentamos buscar el root del paquete subiendo niveles desde src/core/mapping
+    // En desarrollo: agent-workflow/src/core/mapping -> ../../..
+    // En producción (dist): agent-workflow/dist/core/mapping -> ../../..
+    return resolveCorePathFromDir(__dirname);
+}
+/**
+ * Intenta resolver el core instalado en node_modules desde el cwd.
+ * Devuelve null si no hay instalación local.
+ */
+export async function resolveInstalledCorePath(cwd = process.cwd()) {
+    try {
+        const directNodeModules = path.join(cwd, 'node_modules', '@christian-marino-alvarez', 'agentic-workflow');
+        try {
+            await fs.access(path.join(directNodeModules, 'package.json'));
+            return await resolveCorePathFromPackageRoot(directNodeModules);
+        }
+        catch {
+            // Fall back to node resolution from cwd.
+        }
+        const requireFromCwd = createRequire(path.join(cwd, 'package.json'));
+        const pkgPath = requireFromCwd.resolve('@christian-marino-alvarez/agentic-workflow/package.json');
+        const pkgRoot = path.dirname(pkgPath);
+        return await resolveCorePathFromPackageRoot(pkgRoot);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveCorePathFromDir(startDir) {
+    let currentDir = startDir;
+    const maxRetries = 5;
+    for (let i = 0; i < maxRetries; i++) {
+        const potentialRulesPath = path.join(currentDir, 'rules');
+        const potentialWorkflowsPath = path.join(currentDir, 'workflows');
+        try {
+            await fs.access(potentialRulesPath);
+            await fs.access(potentialWorkflowsPath);
+            return currentDir; // Encontrado
+        }
+        catch {
+            currentDir = path.dirname(currentDir);
+        }
+    }
+    throw new Error('No se pudo localizar el core del framework (@cmarino/agentic-workflow). Asegúrate de que el paquete está correctamente instalado.');
+}
+async function resolveCorePathFromPackageRoot(pkgRoot) {
+    const candidates = [pkgRoot, path.join(pkgRoot, 'dist'), path.join(pkgRoot, 'src')];
+    for (const candidate of candidates) {
+        try {
+            const rulesPath = path.join(candidate, 'rules');
+            const workflowsPath = path.join(candidate, 'workflows');
+            await fs.access(rulesPath);
+            await fs.access(workflowsPath);
+            return candidate;
+        }
+        catch {
+            // Not a core root, try next.
+        }
+    }
+    throw new Error('No se pudo localizar el core instalado en node_modules.');
+}

package/dist/core/migration/backup.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function createBackup(cwd) {
+    const agentDir = path.join(cwd, '.agent');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(cwd, `.agent.backup_${timestamp}`);
+    try {
+        await fs.cp(agentDir, backupDir, { recursive: true });
+        return backupDir;
+    }
+    catch (error) {
+        throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/core/migration/detector.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectAgentSystem(cwd) {
+    const agentDir = path.join(cwd, '.agent');
+    try {
+        await fs.access(agentDir);
+    }
+    catch {
+        return 'none';
+    }
+    // Comprobar si es el sistema actual (Portable)
+    try {
+        const rootIndex = await fs.readFile(path.join(agentDir, 'index.md'), 'utf-8');
+        if (rootIndex.includes('id: agent.index')) {
+            return 'current';
+        }
+    }
+    catch {
+        // No hay index.md global
+    }
+    // Comprobar si es legacy (Extensio)
+    try {
+        const rulesIndex = await fs.readFile(path.join(agentDir, 'rules', 'index.md'), 'utf-8');
+        if (rulesIndex.includes('id: rules.index')) {
+            return 'legacy';
+        }
+    }
+    catch {
+        // No hay rules/index.md
+    }
+    return 'legacy'; // Si existe .agent pero no es actual, lo tratamos como legacy para migrar
+}

package/dist/core/migration/transformer.js

@@ -0,0 +1,11 @@
+import matter from 'gray-matter';
+export function transformMarkdownContent(content, newMeta) {
+    const { data, content: body } = matter(content);
+    // Merge existing metadata with new metadata
+    const mergedData = {
+        ...data,
+        ...newMeta
+    };
+    // Return the stringified version with the triple dash separators
+    return matter.stringify(body, mergedData);
+}

package/dist/core/utils/backup.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Utility to manage backups of the .agent directory.
+ */
+export async function performBackup(cwd) {
+    const agentDir = path.join(cwd, '.agent');
+    const backupBaseDir = path.join(cwd, '.agent-backups');
+    // Check if .agent exists
+    try {
+        await fs.access(agentDir);
+    }
+    catch {
+        // No .agent folder, nothing to backup
+        return '';
+    }
+    // Create backup directory with timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(backupBaseDir, timestamp);
+    await fs.mkdir(backupDir, { recursive: true });
+    // Copy .agent to backupDir
+    await copyRecursive(agentDir, path.join(backupDir, '.agent'));
+    return backupDir;
+}
+/**
+ * Helper to copy directories recursively.
+ */
+async function copyRecursive(src, dest) {
+    const stats = await fs.stat(src);
+    const isDirectory = stats.isDirectory();
+    if (isDirectory) {
+        await fs.mkdir(dest, { recursive: true });
+        const files = await fs.readdir(src);
+        for (const file of files) {
+            await copyRecursive(path.join(src, file), path.join(dest, file));
+        }
+    }
+    else {
+        await fs.copyFile(src, dest);
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,160 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { performCreate } from "../cli/commands/create.js";
+import { ContextManager } from "../core/context/manager.js";
+import { resolveCorePath } from "../core/mapping/resolver.js";
+/**
+ * Servidor MCP para el framework Agentic Workflow.
+ * Proporciona herramientas estructuradas para extender el sistema.
+ */
+export async function runMcpServer() {
+    const server = new Server({
+        name: "agentic-workflow-server",
+        version: "1.3.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Configuración del Ciclo de Vida (Lifecycle)
+    const INACTIVITY_TIMEOUT = 30 * 60 * 1000; // 30 minutos
+    let inactivityTimer;
+    const resetInactivityTimer = () => {
+        if (inactivityTimer)
+            clearTimeout(inactivityTimer);
+        inactivityTimer = setTimeout(() => {
+            console.error("MCP Server shutting down due to inactivity...");
+            process.exit(0);
+        }, INACTIVITY_TIMEOUT);
+    };
+    // Iniciar timer inicial
+    resetInactivityTimer();
+    /**
+     * Listado de herramientas disponibles.
+     */
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        resetInactivityTimer();
+        return {
+            tools: [
+                {
+                    name: "create_role",
+                    description: "Crea un nuevo rol (agente) en el proyecto local bajo la carpeta espejo .agent/roles/.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            name: {
+                                type: "string",
+                                description: "Nombre del rol (ej: devops, qa, reviewer)",
+                            },
+                        },
+                        required: ["name"],
+                    },
+                },
+                {
+                    name: "create_workflow",
+                    description: "Crea un nuevo workflow personalizado en el proyecto local bajo la carpeta espejo .agent/workflows/.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            name: {
+                                type: "string",
+                                description: "Nombre del workflow (ej: refactor, release, triage)",
+                            },
+                        },
+                        required: ["name"],
+                    },
+                },
+                {
+                    name: "bootstrap_context",
+                    description: "Genera un bundle consolidado con el índice maestro, índices de dominio, constitución base y roles esenciales en un solo paso (Best Practice).",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+                {
+                    name: "hydrate_context",
+                    description: "Carga dinámicamente el contenido de todos los ficheros asociados a un alias (ej: rules.constitution) de forma consolidada.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            alias: {
+                                type: "string",
+                                description: "Alias del dominio a hidratar (ej: rules.constitution, workflows.modules)",
+                            },
+                        },
+                        required: ["alias"],
+                    },
+                },
+                {
+                    name: "stop_server",
+                    description: "Detiene el servidor MCP inmediatamente.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+            ],
+        };
+    });
+    /**
+     * Manejador de llamadas a herramientas.
+     */
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        resetInactivityTimer();
+        const { name, arguments: args } = request.params;
+        if (name === "create_role" || name === "create_workflow") {
+            const type = name === "create_role" ? "role" : "workflow";
+            const entityName = args.name;
+            if (!entityName) {
+                throw new Error("El nombre de la entidad es obligatorio.");
+            }
+            const result = await performCreate(type, entityName);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result.message,
+                    },
+                ],
+                isError: !result.success,
+            };
+        }
+        if (name === "bootstrap_context") {
+            const corePath = await resolveCorePath();
+            const manager = new ContextManager(process.cwd(), corePath);
+            const bundle = await manager.bootstrapContext();
+            return {
+                content: [{ type: "text", text: bundle }]
+            };
+        }
+        if (name === "hydrate_context") {
+            const corePath = await resolveCorePath();
+            const manager = new ContextManager(process.cwd(), corePath);
+            const alias = args.alias;
+            const files = await manager.resolveAlias(alias);
+            if (files.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No se encontraron ficheros para el alias: ${alias}` }],
+                    isError: true
+                };
+            }
+            const bundle = manager.formatBundle(files);
+            return {
+                content: [{ type: "text", text: bundle }]
+            };
+        }
+        if (name === "stop_server") {
+            setTimeout(() => process.exit(0), 100);
+            return {
+                content: [{ type: "text", text: "Servidor deteniéndose..." }]
+            };
+        }
+        throw new Error(`Herramienta no encontrada: ${name}`);
+    });
+    // Conexión mediante Standard Input/Output (Stdio)
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Agentic Workflow MCP Server running on stdio");
+}

package/dist/rules/constitution/GEMINI.location.md

@@ -0,0 +1,29 @@
+---
+trigger: always_on
+---
+
+# GEMINI LOCATION
+
+This repository DOES NOT version `GEMINI.md`.
+
+Google Antigravity loads `GEMINI.md` from the user path (outside the repository).
+Therefore, the agentic system assumes that `GEMINI.md` exists and is accessible on the local machine.
+
+## Rule
+
+- `GEMINI.md` is PERMANENT and has absolute priority.
+- This file only documents where `GEMINI.md` is located and how it integrates.
+- `GEMINI.md` MUST NOT be copied or duplicated within the repository.
+
+## Minimum Requirements
+
+- The developer machine MUST have `GEMINI.md` available in the user path configured for Google Antigravity.
+- If `GEMINI.md` is not available, any task MUST BE BLOCKED until the environment is corrected.
+
+## Internal Reference
+
+Repository rules reference the global constitution via:
+
+`constitution.GEMINI_location`
+
+This file acts as the unique versioned anchor point for the external `GEMINI.md` constitution.