ai-devx 1.0.4 → 1.0.6

package/src/commands/shell.js

@@ -0,0 +1,358 @@
+const path = require("path");
+const fs = require("fs-extra");
+const chalk = require("chalk");
+const readline = require("readline");
+const config = require("../config");
+const fileUtils = require("../utils/fileSystem");
+
+class InteractiveCLI {
+  constructor(agentPath) {
+    this.agentPath = agentPath;
+    this.workflows = [];
+    this.skills = [];
+    this.agents = [];
+    this.scripts = [];
+    this.rules = [];
+    this.shared = [];
+    this.workflowsPath = path.join(agentPath, "workflows");
+    this.skillsPath = path.join(agentPath, "skills");
+    this.agentsPath = path.join(agentPath, "agents");
+    this.scriptsPath = path.join(agentPath, "scripts");
+    this.rulesPath = path.join(agentPath, "rules");
+    this.sharedPath = path.join(agentPath, ".shared");
+  }
+
+  async loadResources() {
+    // Load workflows
+    if (await fs.pathExists(this.workflowsPath)) {
+      const files = await fs.readdir(this.workflowsPath);
+      this.workflows = files
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => ({
+          name: `/${path.basename(f, ".md")}`,
+          file: f,
+          type: "workflow",
+        }));
+    }
+
+    // Load skills
+    if (await fs.pathExists(this.skillsPath)) {
+      const entries = await fs.readdir(this.skillsPath, {
+        withFileTypes: true,
+      });
+      this.skills = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => ({
+          name: e.name,
+          path: path.join(this.skillsPath, e.name),
+          type: "skill",
+        }));
+    }
+
+    // Load agents
+    if (await fs.pathExists(this.agentsPath)) {
+      const files = await fs.readdir(this.agentsPath);
+      this.agents = files
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => ({
+          name: `@${path.basename(f, ".md")}`,
+          file: f,
+          type: "agent",
+        }));
+    }
+
+    // Load scripts
+    if (await fs.pathExists(this.scriptsPath)) {
+      const files = await fs.readdir(this.scriptsPath);
+      this.scripts = files
+        .filter((f) => f.endsWith(".py"))
+        .map((f) => ({
+          name: f,
+          file: f,
+          type: "script",
+        }));
+    }
+
+    // Load rules
+    if (await fs.pathExists(this.rulesPath)) {
+      const files = await fs.readdir(this.rulesPath);
+      this.rules = files
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => ({
+          name: path.basename(f, ".md"),
+          file: f,
+          type: "rule",
+        }));
+    }
+
+    // Load shared
+    if (await fs.pathExists(this.sharedPath)) {
+      const entries = await fs.readdir(this.sharedPath, {
+        withFileTypes: true,
+      });
+      this.shared = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => ({
+          name: e.name,
+          path: path.join(this.sharedPath, e.name),
+          type: "shared",
+        }));
+    }
+  }
+
+  showHelp() {
+    console.log(chalk.bold("\n📚 Available Commands:\n"));
+
+    console.log(chalk.yellow.bold("Slash Commands (Workflows):"));
+    this.workflows.forEach((w) => {
+      console.log(`  ${chalk.cyan(w.name)} - Workflow command`);
+    });
+
+    console.log(chalk.yellow.bold("\nSkills:"));
+    this.skills.slice(0, 15).forEach((s) => {
+      console.log(`  ${chalk.green(s.name)} - Domain knowledge module`);
+    });
+    if (this.skills.length > 15) {
+      console.log(`  ${chalk.gray(`... and ${this.skills.length - 15} more`)}`);
+    }
+
+    console.log(chalk.yellow.bold("\nAgents:"));
+    this.agents.slice(0, 10).forEach((a) => {
+      console.log(`  ${chalk.magenta(a.name)} - Specialist agent`);
+    });
+    if (this.agents.length > 10) {
+      console.log(`  ${chalk.gray(`... and ${this.agents.length - 10} more`)}`);
+    }
+
+    console.log(chalk.yellow.bold("\nScripts:"));
+    this.scripts.slice(0, 8).forEach((s) => {
+      console.log(`  ${chalk.blue(s.name)} - Automation script`);
+    });
+    if (this.scripts.length > 8) {
+      console.log(`  ${chalk.gray(`... and ${this.scripts.length - 8} more`)}`);
+    }
+
+    console.log(chalk.yellow.bold("\nRules:"));
+    this.rules.forEach((r) => {
+      console.log(`  ${chalk.red(r.name)} - Assistant rules`);
+    });
+
+    if (this.shared.length > 0) {
+      console.log(chalk.yellow.bold("\nShared Resources:"));
+      this.shared.forEach((s) => {
+        console.log(`  ${chalk.gray(s.name)} - Shared utilities`);
+      });
+    }
+
+    console.log(chalk.yellow.bold("\nOther Commands:"));
+    console.log(`  ${chalk.cyan("/help")} - Show this menu`);
+    console.log(`  ${chalk.cyan("/exit")} - Exit interactive mode`);
+    console.log(`  ${chalk.cyan("clear")} - Clear screen`);
+    console.log();
+  }
+
+  async executeWorkflow(workflowName, args = "") {
+    const workflow = this.workflows.find((w) => w.name === workflowName);
+    if (!workflow) {
+      console.log(chalk.red(`❌ Workflow '${workflowName}' not found`));
+      return;
+    }
+
+    const workflowPath = path.join(this.workflowsPath, workflow.file);
+    try {
+      const content = await fs.readFile(workflowPath, "utf-8");
+      console.log(chalk.bold(`\n📄 Workflow: ${workflowName}\n`));
+
+      // Show first 50 lines or until first separator
+      const lines = content.split("\n");
+      const previewLines = [];
+      for (const line of lines) {
+        if (line.startsWith("---") && previewLines.length > 0) break;
+        previewLines.push(line);
+        if (previewLines.length >= 30) break;
+      }
+
+      console.log(previewLines.join("\n"));
+      console.log(chalk.gray("\n... (truncated)"));
+      console.log(chalk.yellow(`\nFull file: ${workflowPath}\n`));
+    } catch (error) {
+      console.log(chalk.red(`❌ Error reading workflow: ${error.message}`));
+    }
+  }
+
+  async executeSkill(skillName) {
+    const skill = this.skills.find((s) => s.name === skillName);
+    if (!skill) {
+      console.log(chalk.red(`❌ Skill '${skillName}' not found`));
+      return;
+    }
+
+    const skillMdPath = path.join(skill.path, "SKILL.md");
+    try {
+      if (await fs.pathExists(skillMdPath)) {
+        const content = await fs.readFile(skillMdPath, "utf-8");
+        console.log(chalk.bold(`\n📚 Skill: ${skillName}\n`));
+
+        const lines = content.split("\n").slice(0, 40);
+        console.log(lines.join("\n"));
+        console.log(chalk.gray("\n... (truncated)"));
+        console.log(chalk.yellow(`\nFull file: ${skillMdPath}\n`));
+      } else {
+        console.log(chalk.bold(`\n📚 Skill: ${skillName}\n`));
+        console.log(`Path: ${skill.path}`);
+
+        const files = await fs.readdir(skill.path);
+        console.log("\nContents:");
+        files.forEach((f) => console.log(`  - ${f}`));
+        console.log();
+      }
+    } catch (error) {
+      console.log(chalk.red(`❌ Error reading skill: ${error.message}`));
+    }
+  }
+
+  async executeAgent(agentName) {
+    const agent = this.agents.find((a) => a.name === agentName);
+    if (!agent) {
+      console.log(chalk.red(`❌ Agent '${agentName}' not found`));
+      return;
+    }
+
+    const agentPath = path.join(this.agentsPath, agent.file);
+    try {
+      const content = await fs.readFile(agentPath, "utf-8");
+      console.log(chalk.bold(`\n🤖 Agent: ${agentName}\n`));
+
+      const lines = content.split("\n").slice(0, 40);
+      console.log(lines.join("\n"));
+      console.log(chalk.gray("\n... (truncated)"));
+      console.log(chalk.yellow(`\nFull file: ${agentPath}\n`));
+    } catch (error) {
+      console.log(chalk.red(`❌ Error reading agent: ${error.message}`));
+    }
+  }
+
+  async executeRule(ruleName) {
+    const rule = this.rules.find((r) => r.name === ruleName);
+    if (!rule) {
+      console.log(chalk.red(`❌ Rule '${ruleName}' not found`));
+      return;
+    }
+
+    const rulePath = path.join(this.rulesPath, rule.file);
+    try {
+      const content = await fs.readFile(rulePath, "utf-8");
+      console.log(chalk.bold(`\n📜 Rule: ${ruleName}\n`));
+
+      const lines = content.split("\n").slice(0, 40);
+      console.log(lines.join("\n"));
+      console.log(chalk.gray("\n... (truncated)"));
+      console.log(chalk.yellow(`\nFull file: ${rulePath}\n`));
+    } catch (error) {
+      console.log(chalk.red(`❌ Error reading rule: ${error.message}`));
+    }
+  }
+
+  async start() {
+    await this.loadResources();
+
+    console.log(
+      chalk.cyan.bold(`
+╔════════════════════════════════════════════════╗
+║     🤖 AI-DEVX Interactive Shell               ║
+║  Type / to see all commands and resources        ║
+║  Type /help for help or /exit to quit            ║
+╚════════════════════════════════════════════════╝
+`),
+    );
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk.cyan("ai-devx> "),
+    });
+
+    rl.prompt();
+
+    rl.on("line", async (line) => {
+      const input = line.trim();
+
+      if (input === "/exit" || input === "exit" || input === "quit") {
+        console.log(chalk.yellow("👋 Goodbye!"));
+        rl.close();
+        return;
+      }
+
+      if (input === "" || input === "/") {
+        this.showHelp();
+      } else if (input === "/help" || input === "help") {
+        console.log(chalk.bold("\n🎯 Quick Guide:\n"));
+        console.log("Type any of the following:");
+        console.log(
+          `  ${chalk.cyan("/")} - Show all available commands and resources`,
+        );
+        console.log(
+          `  ${chalk.cyan("/<workflow>")} - View workflow details (e.g., /plan)`,
+        );
+        console.log(
+          `  ${chalk.cyan("@<agent>")} - View agent details (e.g., @orchestrator)`,
+        );
+        console.log(
+          `  ${chalk.cyan("<skill-name>")} - View skill details (e.g., clean-code)`,
+        );
+        console.log(
+          `  ${chalk.cyan("<rule-name>")} - View rule details (e.g., CLAUDE)`,
+        );
+        console.log(`  ${chalk.cyan("clear")} - Clear the screen`);
+        console.log(`  ${chalk.cyan("/exit")} - Exit interactive mode\n`);
+      } else if (input === "clear") {
+        console.clear();
+      } else if (input.startsWith("/")) {
+        // Workflow command
+        await this.executeWorkflow(input);
+      } else if (input.startsWith("@")) {
+        // Agent command
+        await this.executeAgent(input);
+      } else if (this.skills.find((s) => s.name === input)) {
+        // Skill command
+        await this.executeSkill(input);
+      } else if (this.rules.find((r) => r.name === input)) {
+        // Rule command
+        await this.executeRule(input);
+      } else {
+        console.log(chalk.yellow(`⚠️ Unknown command: ${input}`));
+        console.log(chalk.gray("Type / to see available commands\n"));
+      }
+
+      rl.prompt();
+    });
+
+    rl.on("close", () => {
+      console.log(chalk.yellow("\n👋 Goodbye!"));
+      process.exit(0);
+    });
+  }
+}
+
+async function shellCommand(targetPath) {
+  const cwd = targetPath || process.cwd();
+
+  // Find installed folder
+  const installedFolder = await fileUtils.findInstalledFolder(cwd);
+
+  if (!installedFolder) {
+    console.log(chalk.red(`❌ AI-DEVX not installed in ${cwd}`));
+    console.log(chalk.yellow("Run one of the following:"));
+    console.log(chalk.yellow("  npx ai-devx init"));
+    console.log(chalk.yellow("  npx ai-devx init --assistant claude"));
+    console.log(chalk.yellow("  npx ai-devx init --assistant gemini"));
+    process.exit(1);
+  }
+
+  const agentPath = path.join(path.resolve(cwd), installedFolder);
+
+  const cli = new InteractiveCLI(agentPath);
+  await cli.start();
+}
+
+module.exports = shellCommand;

package/src/commands/status.js

@@ -1,59 +1,96 @@
-const path = require('path');
-const chalk = require('chalk');
-const logger = require('../utils/logger');
-const fileUtils = require('../utils/fileSystem');
-const config = require('../config');
+const path = require("path");
+const chalk = require("chalk");
+const logger = require("../utils/logger");
+const fileUtils = require("../utils/fileSystem");
+const config = require("../config");
 
 async function statusCommand(options) {
   const { path: targetPath } = options;
   const absolutePath = path.resolve(targetPath);
-  const agentPath = path.join(absolutePath, config.AGENT_FOLDER);
-  
+
   logger.blank();
-  logger.info('AI-DEVX Status');
+  logger.info("AI-DEVX Status");
   logger.blank();
-  
-  const isInstalled = await fileUtils.isInstalled(absolutePath);
-  
-  if (!isInstalled) {
-    logger.error('Not installed');
+
+  // Check all possible installations
+  const folderNames = config.getAllFolderNames();
+  const installations = [];
+
+  for (const folder of folderNames) {
+    const isInstalled = await fileUtils.isInstalled(absolutePath, folder);
+    if (isInstalled) {
+      const folderPath = path.join(absolutePath, folder);
+      const version = await fileUtils.getVersion(folderPath);
+      const configData = await fileUtils.readJson(
+        path.join(folderPath, "config.json"),
+      );
+
+      installations.push({
+        folder,
+        path: folderPath,
+        version: version || "unknown",
+        config: configData,
+        assistants: configData?.assistants || [],
+      });
+    }
+  }
+
+  if (installations.length === 0) {
+    logger.error("Not installed");
     logger.info(`Directory: ${absolutePath}`);
     logger.blank();
-    logger.info('Run "ai-devx init" to install');
+    logger.info("Run one of the following:");
+    logger.step("npx ai-devx init                    # Install to .agent/");
+    logger.step("npx ai-devx init --assistant claude # Install to .claude/");
+    logger.step("npx ai-devx init --assistant gemini # Install to .gemini/");
+    logger.blank();
     return;
   }
-  
-  // Get version
-  const version = await fileUtils.getVersion(agentPath);
-  const configData = await fileUtils.readJson(path.join(agentPath, 'config.json'));
-  
-  logger.success('Installed');
+
+  logger.success(
+    `Installed (${installations.length} installation${installations.length > 1 ? "s" : ""})`,
+  );
   logger.blank();
-  logger.info(`Directory: ${agentPath}`);
-  logger.info(`Version: ${chalk.green(version || 'unknown')}`);
-  
-  if (configData) {
-    if (configData.installedAt) {
-      logger.info(`Installed: ${new Date(configData.installedAt).toLocaleDateString()}`);
+
+  installations.forEach((inst, index) => {
+    if (index > 0) logger.blank();
+
+    logger.info(`Installation ${index + 1}:`);
+    logger.step(`Folder: ${chalk.cyan(inst.folder)}`);
+    logger.step(`Path: ${inst.path}`);
+    logger.step(`Version: ${chalk.green(inst.version)}`);
+
+    if (inst.assistants.length > 0) {
+      logger.step(`Assistants: ${inst.assistants.join(", ")}`);
     }
-    if (configData.updatedAt) {
-      logger.info(`Last updated: ${new Date(configData.updatedAt).toLocaleDateString()}`);
+
+    if (inst.config) {
+      if (inst.config.installedAt) {
+        logger.step(
+          `Installed: ${new Date(inst.config.installedAt).toLocaleDateString()}`,
+        );
+      }
+      if (inst.config.updatedAt) {
+        logger.step(
+          `Last updated: ${new Date(inst.config.updatedAt).toLocaleDateString()}`,
+        );
+      }
     }
-  }
-  
+  });
+
   logger.blank();
-  logger.info('Available Components:');
-  logger.step(`Agents: 9 specialist personas`);
-  logger.step(`Skills: Multiple domain knowledge modules`);
-  logger.step(`Workflows: 9 slash commands`);
-  logger.step(`Scripts: Validation and automation tools`);
-  
+  logger.info("Available Components:");
+  logger.step(`Agents: 22 specialist personas`);
+  logger.step(`Skills: 37 domain knowledge modules`);
+  logger.step(`Workflows: 11 slash commands`);
+  logger.step(`Scripts: 4 validation and automation tools`);
+
   logger.blank();
-  logger.info('Quick Commands:');
-  config.WORKFLOWS.slice(0, 5).forEach(wf => {
+  logger.info("Quick Commands:");
+  config.WORKFLOWS.slice(0, 5).forEach((wf) => {
     logger.step(`${chalk.cyan(wf.command)} - ${wf.description}`);
   });
-  
+
   logger.blank();
 }
 

package/src/commands/update.js

@@ -1,74 +1,102 @@
-const path = require('path');
-const fs = require('fs-extra');
-const ora = require('ora');
-const logger = require('../utils/logger');
-const fileUtils = require('../utils/fileSystem');
-const config = require('../config');
+const path = require("path");
+const fs = require("fs-extra");
+const ora = require("ora");
+const logger = require("../utils/logger");
+const fileUtils = require("../utils/fileSystem");
+const config = require("../config");
 
 async function updateCommand(options) {
   const { force, backup, quiet } = options;
-  
-  const spinner = quiet ? null : ora('Checking for updates...').start();
-  
+
+  const spinner = quiet ? null : ora("Checking for updates...").start();
+
   try {
     const cwd = process.cwd();
-    const isInstalled = await fileUtils.isInstalled(cwd);
-    
-    if (!isInstalled) {
-      if (spinner) spinner.stop();
-      logger.error('AI-DEVX is not installed in this directory.');
-      logger.info('Run "ai-devx init" first.');
-      return;
+
+    // Find all installed folders
+    const folderNames = config.getAllFolderNames();
+    const installations = [];
+
+    for (const folder of folderNames) {
+      const isInstalled = await fileUtils.isInstalled(cwd, folder);
+      if (isInstalled) {
+        installations.push(folder);
+      }
     }
-    
-    const agentPath = path.join(cwd, config.AGENT_FOLDER);
-    const currentVersion = await fileUtils.getVersion(agentPath);
-    const latestVersion = '1.0.0'; // In real implementation, fetch from GitHub
-    
-    if (currentVersion === latestVersion && !force) {
+
+    if (installations.length === 0) {
       if (spinner) spinner.stop();
-      logger.success('AI-DEVX is already up to date!');
-      logger.info(`Version: ${currentVersion}`);
+      logger.error("AI-DEVX is not installed in this directory.");
+      logger.info('Run "ai-devx init" first.');
       return;
     }
-    
-    if (spinner) spinner.text = 'Updating templates...';
-    
-    // Create backup if requested
-    if (backup) {
-      const backupPath = await fileUtils.backup(cwd);
-      if (backupPath && !quiet) {
-        logger.info(`Backup created: ${backupPath}`);
+
+    const latestVersion = "1.0.0"; // In real implementation, fetch from GitHub
+    const sourcePath = path.join(__dirname, "../../templates/.agent");
+
+    // Update each installation
+    for (const folder of installations) {
+      const agentPath = path.join(cwd, folder);
+      const currentVersion = await fileUtils.getVersion(agentPath);
+
+      if (spinner) spinner.text = `Updating ${folder}...`;
+
+      // Create backup if requested
+      if (backup) {
+        const backupPath = path.join(cwd, `${folder}.backup.${Date.now()}`);
+        await fs.copy(agentPath, backupPath);
+        if (!quiet) {
+          logger.info(`Backup created: ${backupPath}`);
+        }
+      }
+
+      // Read existing config to preserve assistant settings
+      const configFile = path.join(agentPath, "config.json");
+      const existingConfig = (await fileUtils.readJson(configFile)) || {};
+      const assistants = existingConfig.assistants || ["claude", "gemini"];
+
+      // Copy updated templates
+      await fileUtils.copyDir(sourcePath, agentPath, { force: true });
+
+      // Re-apply assistant filtering
+      const rulesPath = path.join(agentPath, "rules");
+      const validAssistants = ["claude", "gemini"];
+
+      for (const ast of validAssistants) {
+        if (!assistants.includes(ast)) {
+          const ruleFile = path.join(rulesPath, `${ast.toUpperCase()}.md`);
+          try {
+            await fs.remove(ruleFile);
+          } catch (e) {
+            // File might not exist, ignore
+          }
+        }
       }
+
+      // Update version file
+      const versionFile = path.join(agentPath, "VERSION");
+      await fs.writeFile(versionFile, latestVersion);
+
+      // Update config
+      existingConfig.version = latestVersion;
+      existingConfig.updatedAt = new Date().toISOString();
+      existingConfig.assistants = assistants;
+      await fileUtils.writeJson(configFile, existingConfig);
     }
-    
-    // Copy updated templates
-    const sourcePath = path.join(__dirname, '../../templates/.agent');
-    await fileUtils.copyDir(sourcePath, agentPath, { force: true });
-    
-    // Update version file
-    const versionFile = path.join(agentPath, 'VERSION');
-    await fs.writeFile(versionFile, latestVersion);
-    
-    // Update config
-    const configFile = path.join(agentPath, 'config.json');
-    const existingConfig = await fileUtils.readJson(configFile) || {};
-    existingConfig.version = latestVersion;
-    existingConfig.updatedAt = new Date().toISOString();
-    await fileUtils.writeJson(configFile, existingConfig);
-    
-    if (spinner) spinner.succeed('AI-DEVX updated successfully!');
-    
+
+    if (spinner) spinner.succeed("AI-DEVX updated successfully!");
+
     if (!quiet) {
       logger.blank();
-      logger.success(`Updated to version: ${latestVersion}`);
-      if (currentVersion) {
-        logger.info(`Previous version: ${currentVersion}`);
-      }
+      logger.success(
+        `Updated ${installations.length} installation${installations.length > 1 ? "s" : ""} to version: ${latestVersion}`,
+      );
+      installations.forEach((folder) => {
+        logger.info(`  - ${folder}/`);
+      });
     }
-    
   } catch (error) {
-    if (spinner) spinner.fail('Update failed');
+    if (spinner) spinner.fail("Update failed");
     logger.error(error.message);
     process.exit(1);
   }