ai-devx 1.0.4 → 1.0.5

package/bin/cli.js

@@ -6,6 +6,7 @@ const pkg = require("../package.json");
 const initCommand = require("../src/commands/init");
 const updateCommand = require("../src/commands/update");
 const statusCommand = require("../src/commands/status");
+const shellCommand = require("../src/commands/shell");
 
 console.log(
   chalk.cyan.bold(`
@@ -59,6 +60,13 @@ program
   .option("-p, --path <path>", "Check specific directory", process.cwd())
   .action(statusCommand);
 
+program
+  .command("shell [path]")
+  .description(
+    "Start interactive shell to browse skills, agents, and workflows",
+  )
+  .action(shellCommand);
+
 program.on("--help", () => {
   console.log("");
   console.log(chalk.bold("Examples:"));
@@ -77,6 +85,9 @@ program.on("--help", () => {
   console.log(
     "  $ ai-devx init --assistant claude,gemini # Install with both assistants",
   );
+  console.log(
+    "  $ ai-devx shell                         # Start interactive shell",
+  );
   console.log("  $ ai-devx update                        # Update templates");
   console.log(
     "  $ ai-devx status                        # Check installation status",
@@ -84,6 +95,7 @@ program.on("--help", () => {
   console.log("");
   console.log(chalk.bold("Quick Start:"));
   console.log("  $ npx ai-devx init");
+  console.log("  $ npx ai-devx shell");
   console.log("");
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-devx",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "AI Agent templates with Skills, Agents, and Workflows for enhanced coding assistance",
   "main": "src/index.js",
   "bin": {

package/src/commands/shell.js

@@ -0,0 +1,349 @@
+const path = require("path");
+const fs = require("fs-extra");
+const chalk = require("chalk");
+const readline = require("readline");
+
+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();
+  const agentPath = path.join(path.resolve(cwd), ".agent");
+
+  if (!(await fs.pathExists(agentPath))) {
+    console.log(chalk.red(`❌ AI-DEVX not installed in ${cwd}`));
+    console.log(chalk.yellow("Run: npx ai-devx init"));
+    process.exit(1);
+  }
+
+  const cli = new InteractiveCLI(agentPath);
+  await cli.start();
+}
+
+module.exports = shellCommand;