agentic-kdd 2.0.0

package/README.md

@@ -0,0 +1,68 @@
+# agentic-kdd CLI
+
+Install [Agentic KDD](https://github.com/Adrianlpz211/Agentic-KDD) in any project with one command.
+
+## Install
+
+```bash
+npm install -g agentic-kdd
+```
+
+## Usage
+
+### Initialize a project
+
+```bash
+cd your-project
+akdd init
+```
+
+Detects your stack, asks 3 questions, and installs Agentic KDD.
+Then open the project in Cursor or Claude Code and type:
+
+```
+aa: [your task]
+```
+
+### Update to latest version
+
+```bash
+akdd update
+```
+
+Updates agent instructions to the latest version.
+Your memory, config, and knowledge base are never touched.
+
+## What gets installed
+
+```
+your-project/
+├── CLAUDE.md                    ← Claude Code reads this automatically
+├── _LOCKS.md                    ← parallel instance coordination
+├── _output/                     ← auto-generated decision logs
+├── .cursor/rules/agentic.mdc    ← Cursor reads this automatically
+└── .agentic/
+    ├── config.md                ← auto-configured for your stack
+    ├── PLAN.md                  ← active task tracker
+    ├── memoria/                 ← KDD knowledge base
+    │   ├── trabajo.md
+    │   ├── errores.md
+    │   ├── patrones.md
+    │   └── decisiones.md
+    ├── agentes/                 ← 8 agent instruction files
+    └── conocimiento/            ← drop your project docs here
+```
+
+## Requirements
+
+- Node.js 18+
+- curl (pre-installed on Mac/Linux; on Windows use Git Bash)
+
+## Links
+
+- [GitHub](https://github.com/Adrianlpz211/Agentic-KDD)
+- [Documentation](https://github.com/Adrianlpz211/Agentic-KDD/blob/main/docs/kdd-methodology.md)
+
+## License
+
+MIT

package/bin/akdd.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { init } = require('../src/init');
+const { update } = require('../src/update');
+const pkg = require('../package.json');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const HELP = `
+  Agentic KDD v${pkg.version}
+  Autonomous development pipeline with Knowledge-Driven Development
+
+  Usage:
+    akdd init      Install Agentic KDD in the current project
+    akdd update    Update to the latest version (keeps your memory intact)
+    akdd --version Show version
+    akdd --help    Show this help
+
+  After init, open the project in Cursor or Claude Code and type:
+    aa: [your task]
+`;
+
+switch (command) {
+  case 'init':
+    init();
+    break;
+  case 'update':
+    update();
+    break;
+  case '--version':
+  case '-v':
+    console.log(pkg.version);
+    break;
+  case '--help':
+  case '-h':
+  case undefined:
+    console.log(HELP);
+    break;
+  default:
+    console.log(`\n  Unknown command: ${command}`);
+    console.log('  Run akdd --help for usage\n');
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "agentic-kdd",
+  "version": "2.0.0",
+  "description": "Autonomous development pipeline with Knowledge-Driven Development. Works with Cursor and Claude Code. Just type aa:",
+  "main": "src/index.js",
+  "bin": {
+    "akdd": "./bin/akdd.js"
+  },
+  "scripts": {
+    "test": "node bin/akdd.js --version"
+  },
+  "keywords": [
+    "ai",
+    "cursor",
+    "claude-code",
+    "autonomous",
+    "development",
+    "pipeline",
+    "kdd",
+    "knowledge-driven",
+    "agentic"
+  ],
+  "author": "Adrianlpz211",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Adrianlpz211/Agentic-KDD.git"
+  },
+  "homepage": "https://github.com/Adrianlpz211/Agentic-KDD",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "fs-extra": "^11.2.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6"
+  }
+}

package/src/init.js

@@ -0,0 +1,309 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// Chalk y ora en versiones CommonJS
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+
+const GITHUB_REPO = 'Adrianlpz211/Agentic-KDD';
+const GITHUB_API = `https://api.github.com/repos/${GITHUB_REPO}/tarball/main`;
+const TEMP_DIR = path.join(require('os').tmpdir(), 'agentic-kdd-download');
+
+// ── Detectar stack del proyecto ────────────────────────────────
+function detectStack(projectPath) {
+  const stack = {
+    hasNode: false,
+    hasPhp: false,
+    hasPython: false,
+    framework: '—',
+    packageManager: 'npm',
+    commands: {
+      install: 'npm install',
+      dev: 'npm run dev',
+      build: 'npm run build',
+      test: 'npm test',
+      lint: 'npm run lint'
+    }
+  };
+
+  // Node.js
+  if (fs.existsSync(path.join(projectPath, 'package.json'))) {
+    stack.hasNode = true;
+    const pkg = fs.readJsonSync(path.join(projectPath, 'package.json'), { throws: false }) || {};
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // Package manager
+    if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
+      stack.packageManager = 'pnpm';
+      stack.commands.install = 'pnpm install';
+      stack.commands.dev = 'pnpm dev';
+      stack.commands.build = 'pnpm build';
+      stack.commands.test = 'pnpm test';
+      stack.commands.lint = 'pnpm lint';
+    } else if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
+      stack.packageManager = 'yarn';
+      stack.commands.install = 'yarn install';
+      stack.commands.dev = 'yarn dev';
+      stack.commands.build = 'yarn build';
+      stack.commands.test = 'yarn test';
+      stack.commands.lint = 'yarn lint';
+    }
+
+    // Framework
+    if (deps['next']) stack.framework = `Next.js ${deps['next'].replace('^', '')}`;
+    else if (deps['react']) stack.framework = `React ${deps['react'].replace('^', '')}`;
+    else if (deps['vue']) stack.framework = `Vue ${deps['vue'].replace('^', '')}`;
+    else if (deps['express']) stack.framework = `Express ${deps['express'].replace('^', '')}`;
+    else if (deps['fastify']) stack.framework = `Fastify`;
+    else if (deps['@nestjs/core']) stack.framework = `NestJS`;
+  }
+
+  // PHP
+  if (fs.existsSync(path.join(projectPath, 'composer.json'))) {
+    stack.hasPhp = true;
+    stack.packageManager = 'composer';
+    stack.commands.install = 'composer install';
+    stack.commands.dev = 'php artisan serve';
+    stack.commands.build = 'composer build';
+    stack.commands.test = './vendor/bin/phpunit';
+    stack.commands.lint = 'composer lint';
+    const composer = fs.readJsonSync(path.join(projectPath, 'composer.json'), { throws: false }) || {};
+    const require = composer.require || {};
+    if (require['laravel/framework']) stack.framework = 'Laravel';
+  }
+
+  // Python
+  if (fs.existsSync(path.join(projectPath, 'pyproject.toml')) ||
+      fs.existsSync(path.join(projectPath, 'requirements.txt'))) {
+    stack.hasPython = true;
+    stack.packageManager = 'pip';
+    stack.commands.install = 'pip install -r requirements.txt';
+    stack.commands.dev = 'uvicorn main:app --reload';
+    stack.commands.build = 'pip install -e .';
+    stack.commands.test = 'pytest';
+    stack.commands.lint = 'flake8';
+  }
+
+  return stack;
+}
+
+// ── Descargar archivos de Agentic KDD desde GitHub ────────────
+async function downloadFromGitHub(spinner) {
+  return new Promise((resolve, reject) => {
+    spinner.text = 'Downloading Agentic KDD from GitHub...';
+
+    const tmpFile = path.join(require('os').tmpdir(), 'agentic-kdd.tar.gz');
+
+    // Usar curl o wget si están disponibles (más confiable que https nativo)
+    try {
+      execSync(`curl -sL "https://github.com/${GITHUB_REPO}/archive/refs/heads/main.tar.gz" -o "${tmpFile}"`, {
+        stdio: 'pipe'
+      });
+
+      // Extraer
+      fs.ensureDirSync(TEMP_DIR);
+      execSync(`tar -xzf "${tmpFile}" -C "${TEMP_DIR}" --strip-components=1`, {
+        stdio: 'pipe'
+      });
+
+      fs.removeSync(tmpFile);
+      resolve(TEMP_DIR);
+    } catch (err) {
+      reject(new Error('Could not download from GitHub. Check your internet connection.'));
+    }
+  });
+}
+
+// ── Copiar archivos de Agentic al proyecto ─────────────────────
+function copyAgenticFiles(sourcePath, projectPath, spinner) {
+  const filesToCopy = [
+    '.agentic',
+    '.cursor',
+    'CLAUDE.md',
+    '_LOCKS.md',
+    '_output',
+    'docs'
+  ];
+
+  spinner.text = 'Installing Agentic KDD files...';
+
+  for (const file of filesToCopy) {
+    const src = path.join(sourcePath, file);
+    const dest = path.join(projectPath, file);
+
+    if (fs.existsSync(src)) {
+      // No sobreescribir memoria si ya existe
+      if (file === '.agentic' && fs.existsSync(dest)) {
+        // Solo actualizar agentes, no memoria ni config
+        const agentsSrc = path.join(src, 'agentes');
+        const agentsDest = path.join(dest, 'agentes');
+        if (fs.existsSync(agentsSrc)) {
+          fs.copySync(agentsSrc, agentsDest, { overwrite: true });
+        }
+        // Copiar conocimiento README si no existe
+        const knowledgeReadmeSrc = path.join(src, 'conocimiento', 'README.md');
+        const knowledgeReadmeDest = path.join(dest, 'conocimiento', 'README.md');
+        if (fs.existsSync(knowledgeReadmeSrc) && !fs.existsSync(knowledgeReadmeDest)) {
+          fs.copySync(knowledgeReadmeSrc, knowledgeReadmeDest);
+        }
+      } else {
+        fs.copySync(src, dest, { overwrite: true });
+      }
+    }
+  }
+}
+
+// ── Configurar config.md con el stack detectado ────────────────
+function configureProject(projectPath, stack, answers) {
+  const configPath = path.join(projectPath, '.agentic', 'config.md');
+
+  if (!fs.existsSync(configPath)) return;
+
+  const projectName = answers.name || path.basename(projectPath);
+  const projectDesc = answers.description || '—';
+  const isNew = answers.isNew;
+
+  const config = `# Agentic KDD — Configuración del proyecto
+CONFIGURADO: SI
+VERSION: 2.0
+
+---
+
+## Proyecto
+Nombre: ${projectName}
+Descripción: ${projectDesc}
+Tipo: ${isNew ? 'NUEVO' : 'EXISTENTE'}
+
+## Stack
+\`\`\`yaml
+frontend:
+  framework: ${stack.framework}
+  language: ${stack.hasPhp ? 'PHP' : stack.hasPython ? 'Python' : 'TypeScript'}
+
+backend:
+  runtime: ${stack.hasNode ? 'Node.js' : stack.hasPhp ? 'PHP' : 'Python'}
+  framework: ${stack.framework}
+  base_datos: —
+
+devops:
+  package_manager: ${stack.packageManager}
+
+commands:
+  install: ${stack.commands.install}
+  dev: ${stack.commands.dev}
+  build: ${stack.commands.build}
+  test: ${stack.commands.test}
+  lint: ${stack.commands.lint}
+\`\`\`
+
+## Arquitectura
+_El agente Setup completa esto al analizar el proyecto._
+
+## Módulos
+### Implementados
+_Ninguno aún._
+
+### Pendientes
+_Ninguno aún._
+
+## Archivos compartidos críticos
+_El Setup los detecta._
+
+## Reglas del proyecto
+_Se definen durante el desarrollo._
+
+## Sinónimos del proyecto
+_Sin sinónimos registrados aún._
+`;
+
+  fs.writeFileSync(configPath, config, 'utf8');
+}
+
+// ── Comando principal: akdd init ───────────────────────────────
+async function init() {
+  const projectPath = process.cwd();
+
+  console.log('\n' + chalk.bold.blue('  Agentic KDD') + chalk.gray(' — autonomous development pipeline'));
+  console.log(chalk.gray('  github.com/Adrianlpz211/Agentic-KDD\n'));
+
+  // Verificar si ya está instalado
+  const alreadyInstalled = fs.existsSync(path.join(projectPath, '.agentic', 'config.md'));
+  if (alreadyInstalled) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.yellow('Agentic KDD is already installed in this project. Reinstall?'),
+      default: false
+    }]);
+    if (!confirm) {
+      console.log(chalk.gray('\n  Run akdd update to update without losing your memory.\n'));
+      return;
+    }
+  }
+
+  // Detectar stack
+  const spinner = ora({ text: 'Detecting project stack...', color: 'blue' }).start();
+  const stack = detectStack(projectPath);
+  spinner.succeed(chalk.green(`Stack detected: ${stack.framework} (${stack.packageManager})`));
+
+  // Preguntas
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Project name:',
+      default: path.basename(projectPath)
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'What does this project do? (1-2 lines):',
+      default: '—'
+    },
+    {
+      type: 'confirm',
+      name: 'isNew',
+      message: 'Is this a new project (from scratch)?',
+      default: !fs.existsSync(path.join(projectPath, 'src')) &&
+               !fs.existsSync(path.join(projectPath, 'app'))
+    }
+  ]);
+
+  // Descargar e instalar
+  const installSpinner = ora({ text: 'Downloading Agentic KDD...', color: 'blue' }).start();
+
+  try {
+    const sourcePath = await downloadFromGitHub(installSpinner);
+
+    installSpinner.text = 'Installing files...';
+    copyAgenticFiles(sourcePath, projectPath, installSpinner);
+
+    installSpinner.text = 'Configuring project...';
+    configureProject(projectPath, stack, answers);
+
+    // Limpiar temp
+    fs.removeSync(TEMP_DIR);
+
+    installSpinner.succeed(chalk.green('Agentic KDD installed successfully!'));
+
+    // Mensaje final
+    console.log('\n' + chalk.bold('  Ready. Open this project in Cursor or Claude Code and type:\n'));
+    console.log(chalk.cyan('  aa: configurar') + chalk.gray('   ← let the Setup agent fine-tune the configuration'));
+    console.log(chalk.cyan('  aa: [your task]') + chalk.gray('  ← start building\n'));
+
+    console.log(chalk.gray('  Documentation: https://github.com/Adrianlpz211/Agentic-KDD\n'));
+
+  } catch (err) {
+    installSpinner.fail(chalk.red('Installation failed'));
+    console.error(chalk.red('\n  Error: ' + err.message));
+    console.log(chalk.gray('  Try downloading manually from: https://github.com/Adrianlpz211/Agentic-KDD\n'));
+    process.exit(1);
+  }
+}
+
+module.exports = { init };

package/src/update.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const GITHUB_REPO = 'Adrianlpz211/Agentic-KDD';
+const TEMP_DIR = path.join(require('os').tmpdir(), 'agentic-kdd-update');
+
+// ── Comando: akdd update ───────────────────────────────────────
+async function update() {
+  const projectPath = process.cwd();
+
+  console.log('\n' + chalk.bold.blue('  Agentic KDD') + chalk.gray(' — updating...\n'));
+
+  // Verificar que está instalado
+  if (!fs.existsSync(path.join(projectPath, '.agentic', 'config.md'))) {
+    console.log(chalk.yellow('  Agentic KDD is not installed in this project.'));
+    console.log(chalk.gray('  Run akdd init to install it.\n'));
+    process.exit(1);
+  }
+
+  const spinner = ora({ text: 'Downloading latest version from GitHub...', color: 'blue' }).start();
+
+  try {
+    const tmpFile = path.join(require('os').tmpdir(), 'agentic-kdd-update.tar.gz');
+
+    // Descargar
+    execSync(
+      `curl -sL "https://github.com/${GITHUB_REPO}/archive/refs/heads/main.tar.gz" -o "${tmpFile}"`,
+      { stdio: 'pipe' }
+    );
+
+    // Extraer
+    fs.ensureDirSync(TEMP_DIR);
+    execSync(`tar -xzf "${tmpFile}" -C "${TEMP_DIR}" --strip-components=1`, { stdio: 'pipe' });
+    fs.removeSync(tmpFile);
+
+    spinner.text = 'Updating agents (keeping your memory intact)...';
+
+    // Actualizar SOLO los agentes — no tocar memoria ni config
+    const agentsSrc = path.join(TEMP_DIR, '.agentic', 'agentes');
+    const agentsDest = path.join(projectPath, '.agentic', 'agentes');
+
+    if (fs.existsSync(agentsSrc)) {
+      fs.copySync(agentsSrc, agentsDest, { overwrite: true });
+    }
+
+    // Actualizar CLAUDE.md y cursor rules
+    const filesToUpdate = ['CLAUDE.md', '_LOCKS.md'];
+    for (const file of filesToUpdate) {
+      const src = path.join(TEMP_DIR, file);
+      const dest = path.join(projectPath, file);
+      if (fs.existsSync(src)) {
+        fs.copySync(src, dest, { overwrite: true });
+      }
+    }
+
+    // Actualizar cursor rules
+    const cursorSrc = path.join(TEMP_DIR, '.cursor');
+    const cursorDest = path.join(projectPath, '.cursor');
+    if (fs.existsSync(cursorSrc)) {
+      fs.copySync(cursorSrc, cursorDest, { overwrite: true });
+    }
+
+    // Limpiar temp
+    fs.removeSync(TEMP_DIR);
+
+    spinner.succeed(chalk.green('Updated successfully!'));
+
+    console.log('\n' + chalk.bold('  What was updated:'));
+    console.log(chalk.gray('  ✓ Agent instructions (.agentic/agentes/)'));
+    console.log(chalk.gray('  ✓ CLAUDE.md'));
+    console.log(chalk.gray('  ✓ Cursor rules\n'));
+
+    console.log(chalk.bold('  What was kept intact:'));
+    console.log(chalk.gray('  ✓ Your project memory (.agentic/memoria/)'));
+    console.log(chalk.gray('  ✓ Your project config (.agentic/config.md)'));
+    console.log(chalk.gray('  ✓ Your knowledge base (.agentic/conocimiento/)'));
+    console.log(chalk.gray('  ✓ Your PLAN.md\n'));
+
+  } catch (err) {
+    spinner.fail(chalk.red('Update failed'));
+    console.error(chalk.red('\n  Error: ' + err.message));
+    console.log(chalk.gray('  Check your internet connection and try again.\n'));
+    process.exit(1);
+  }
+}
+
+module.exports = { update };