mother-brain 0.0.5 → 0.0.7

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/init.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+async function init(options = {}) {
+  const cwd = process.cwd();
+  const skillsDir = path.join(cwd, ".github", "skills");
+  const motherBrainDir = path.join(cwd, ".mother-brain");
+  console.log(chalk.cyan("\n\u{1F9E0} Initializing Mother Brain...\n"));
+  const versionFile = path.join(motherBrainDir, "version.json");
+  if (await fs.pathExists(versionFile) && !options.force) {
+    const version = await fs.readJSON(versionFile);
+    console.log(chalk.yellow(`Mother Brain is already installed (v${version.installed})`));
+    console.log(chalk.dim("Use --force to reinstall, or run: mother-brain update\n"));
+    return;
+  }
+  const packageRoot = path.resolve(__dirname, "..");
+  const sourceSkillsDir = path.join(packageRoot, "skills");
+  const coreSkills = ["mother-brain", "child-brain", "skill-creator"];
+  await fs.ensureDir(skillsDir);
+  await fs.ensureDir(path.join(motherBrainDir, "docs"));
+  let copiedCount = 0;
+  for (const skill of coreSkills) {
+    const sourcePath = path.join(sourceSkillsDir, skill);
+    const destPath = path.join(skillsDir, skill);
+    if (await fs.pathExists(sourcePath)) {
+      const exists = await fs.pathExists(destPath);
+      if (exists && !options.force) {
+        console.log(chalk.yellow(`  \u26A0 ${skill} already exists (skipping)`));
+        continue;
+      }
+      await fs.copy(sourcePath, destPath, { overwrite: true });
+      console.log(chalk.green(`  \u2713 ${skill}`));
+      copiedCount++;
+    } else {
+      console.log(chalk.red(`  \u2717 ${skill} not found in package`));
+    }
+  }
+  const pkg = await fs.readJSON(path.join(packageRoot, "package.json"));
+  await fs.writeJSON(versionFile, {
+    installed: pkg.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, { spaces: 2 });
+  const sessionFile = path.join(motherBrainDir, "session-state.json");
+  if (!await fs.pathExists(sessionFile)) {
+    await fs.writeJSON(sessionFile, {
+      project: null,
+      currentPhase: null,
+      currentTask: null,
+      tasksCompleted: [],
+      lastSession: (/* @__PURE__ */ new Date()).toISOString(),
+      installedVersion: pkg.version,
+      skills: []
+    }, { spaces: 2 });
+  }
+  console.log(chalk.cyan("\n\u2705 Mother Brain initialized!\n"));
+  console.log("Next steps:");
+  console.log(chalk.dim("  1. Commit the new files to your repo"));
+  console.log(chalk.dim("  2. Open GitHub Copilot CLI"));
+  console.log(chalk.dim("  3. Type: /mother-brain\n"));
+  if (copiedCount > 0) {
+    console.log(chalk.green(`Added ${copiedCount} skill(s) to .github/skills/`));
+  }
+  console.log(chalk.green("Created .mother-brain/ for project state\n"));
+}
+
+// src/commands/update.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import chalk2 from "chalk";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var execAsync = promisify(exec);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+async function update() {
+  const cwd = process.cwd();
+  const skillsDir = path2.join(cwd, ".github", "skills");
+  const motherBrainDir = path2.join(cwd, ".mother-brain");
+  const versionFile = path2.join(motherBrainDir, "version.json");
+  console.log(chalk2.cyan("\n\u{1F9E0} Updating Mother Brain...\n"));
+  if (!await fs2.pathExists(versionFile)) {
+    console.log(chalk2.yellow("Mother Brain is not initialized in this project."));
+    console.log(chalk2.dim("Run: mother-brain init\n"));
+    return;
+  }
+  const currentVersion = await fs2.readJSON(versionFile);
+  let latestVersion;
+  try {
+    const { stdout } = await execAsync("npm view mother-brain version");
+    latestVersion = stdout.trim();
+  } catch {
+    console.log(chalk2.yellow("Could not check npm for latest version."));
+    console.log(chalk2.dim("Using bundled package version instead.\n"));
+    const packageRoot = path2.resolve(__dirname2, "..");
+    const pkg = await fs2.readJSON(path2.join(packageRoot, "package.json"));
+    latestVersion = pkg.version;
+  }
+  console.log(chalk2.dim(`Installed: v${currentVersion.installed}`));
+  console.log(chalk2.dim(`Latest:    v${latestVersion}
+`));
+  if (currentVersion.installed === latestVersion) {
+    console.log(chalk2.green("\u2705 Already on the latest version!\n"));
+    return;
+  }
+  console.log(chalk2.dim("Downloading latest version..."));
+  try {
+    const tempDir = path2.join(cwd, ".mother-brain", ".update-temp");
+    await fs2.ensureDir(tempDir);
+    await execAsync(`npm pack mother-brain@${latestVersion} --pack-destination "${tempDir}"`);
+    const files = await fs2.readdir(tempDir);
+    const tarball = files.find((f) => f.endsWith(".tgz"));
+    if (!tarball) {
+      throw new Error("Could not find downloaded package");
+    }
+    await execAsync(`tar -xzf "${path2.join(tempDir, tarball)}" -C "${tempDir}"`);
+    const extractedSkillsDir = path2.join(tempDir, "package", "skills");
+    const coreSkills = ["mother-brain", "child-brain", "skill-creator"];
+    for (const skill of coreSkills) {
+      const sourcePath = path2.join(extractedSkillsDir, skill);
+      const destPath = path2.join(skillsDir, skill);
+      if (await fs2.pathExists(sourcePath)) {
+        await fs2.copy(sourcePath, destPath, { overwrite: true });
+        console.log(chalk2.green(`  \u2713 Updated ${skill}`));
+      }
+    }
+    await fs2.remove(tempDir);
+    await fs2.writeJSON(versionFile, {
+      installed: latestVersion,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      previousVersion: currentVersion.installed
+    }, { spaces: 2 });
+    console.log(chalk2.cyan(`
+\u2705 Updated to v${latestVersion}!
+`));
+    console.log(chalk2.dim("Don't forget to commit the updated files.\n"));
+  } catch (error) {
+    console.log(chalk2.red("Failed to download update."));
+    console.log(chalk2.dim("Try running: npx mother-brain@latest init --force\n"));
+  }
+}
+
+// src/commands/status.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+import chalk3 from "chalk";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var execAsync2 = promisify2(exec2);
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+async function status() {
+  const cwd = process.cwd();
+  const motherBrainDir = path3.join(cwd, ".mother-brain");
+  const versionFile = path3.join(motherBrainDir, "version.json");
+  const skillsDir = path3.join(cwd, ".github", "skills");
+  console.log(chalk3.cyan("\n\u{1F9E0} Mother Brain Status\n"));
+  if (!await fs3.pathExists(versionFile)) {
+    console.log(chalk3.yellow("Not initialized in this project."));
+    console.log(chalk3.dim("Run: mother-brain init\n"));
+    return;
+  }
+  const currentVersion = await fs3.readJSON(versionFile);
+  const packageRoot = path3.resolve(__dirname3, "..");
+  const pkg = await fs3.readJSON(path3.join(packageRoot, "package.json"));
+  console.log(chalk3.white("Installed version: ") + chalk3.green(`v${currentVersion.installed}`));
+  console.log(chalk3.white("Package version:   ") + chalk3.dim(`v${pkg.version}`));
+  try {
+    const { stdout } = await execAsync2("npm view @super-state/mother-brain version 2>/dev/null");
+    const latestVersion = stdout.trim();
+    if (latestVersion && latestVersion !== currentVersion.installed) {
+      console.log(chalk3.yellow(`
+\u2B06\uFE0F  Update available: v${latestVersion}`));
+      console.log(chalk3.dim("Run: mother-brain update\n"));
+    } else {
+      console.log(chalk3.green("\n\u2713 Up to date\n"));
+    }
+  } catch {
+    console.log(chalk3.dim("\n(Could not check for updates)\n"));
+  }
+  console.log(chalk3.white("Installed skills:"));
+  if (await fs3.pathExists(skillsDir)) {
+    const skills = await fs3.readdir(skillsDir);
+    const coreSkills = ["mother-brain", "child-brain", "skill-creator"];
+    for (const skill of skills) {
+      const skillPath = path3.join(skillsDir, skill);
+      const stat = await fs3.stat(skillPath);
+      if (stat.isDirectory()) {
+        const isCore = coreSkills.includes(skill);
+        const label = isCore ? chalk3.dim(" (core)") : chalk3.cyan(" (project)");
+        console.log(chalk3.green(`  \u2713 ${skill}`) + label);
+      }
+    }
+  } else {
+    console.log(chalk3.dim("  No skills found"));
+  }
+  const sessionFile = path3.join(motherBrainDir, "session-state.json");
+  if (await fs3.pathExists(sessionFile)) {
+    const session = await fs3.readJSON(sessionFile);
+    if (session.project) {
+      console.log(chalk3.white("\nProject: ") + chalk3.cyan(session.project));
+      if (session.currentPhase) {
+        console.log(chalk3.dim(`  Phase ${session.currentPhase}`));
+      }
+    }
+  }
+  console.log("");
+}
+
+// src/commands/analyze.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var EXPECTED_SECTIONS = [
+  { name: "Frontmatter", required: true, pattern: /^---\r?\n[\s\S]*?\r?\n---/m, description: "YAML metadata block" },
+  { name: "name", required: true, pattern: /^name:\s*.+$/m, description: "Skill name in frontmatter" },
+  { name: "description", required: true, pattern: /^description:\s*.+$/m, description: "Skill description" },
+  { name: "allowed-tools", required: false, pattern: /^allowed-tools:\s*.+$/m, description: "List of allowed tools" },
+  { name: "Purpose section", required: true, pattern: /^##?\s*Purpose/im, description: "Explains what the skill does" },
+  { name: "Steps section", required: false, pattern: /^##?\s*Steps/im, description: "Step-by-step instructions" },
+  { name: "Examples", required: false, pattern: /(^##?\s*Example|```)/im, description: "Usage examples" }
+];
+function analyzeSkill(skillPath, skillName) {
+  const skillMdPath = join(skillPath, "SKILL.md");
+  const analysis = {
+    name: skillName,
+    path: skillPath,
+    issues: [],
+    suggestions: [],
+    score: 100
+  };
+  if (!existsSync(skillMdPath)) {
+    analysis.issues.push("Missing SKILL.md file");
+    analysis.score = 0;
+    return analysis;
+  }
+  const content = readFileSync(skillMdPath, "utf-8");
+  for (const section of EXPECTED_SECTIONS) {
+    if (!section.pattern.test(content)) {
+      if (section.required) {
+        analysis.issues.push(`Missing required: ${section.name} - ${section.description}`);
+        analysis.score -= 15;
+      } else {
+        analysis.suggestions.push(`Consider adding: ${section.name} - ${section.description}`);
+        analysis.score -= 5;
+      }
+    }
+  }
+  const lines = content.split("\n").length;
+  if (lines < 20) {
+    analysis.suggestions.push("Skill is quite short - consider adding more detail");
+    analysis.score -= 5;
+  } else if (lines > 2e3) {
+    analysis.suggestions.push("Skill is very long - consider splitting into sub-skills");
+    analysis.score -= 5;
+  }
+  if (!/wizard|ask_user|choices/i.test(content)) {
+    analysis.suggestions.push("Consider adding wizard-style prompts for user input");
+  }
+  if (!/validation|verify|check/i.test(content)) {
+    analysis.suggestions.push("Consider adding validation steps");
+  }
+  analysis.score = Math.max(0, analysis.score);
+  return analysis;
+}
+function printAnalysis(analysis) {
+  const scoreEmoji = analysis.score >= 80 ? "\u2705" : analysis.score >= 50 ? "\u26A0\uFE0F" : "\u274C";
+  console.log(`
+${scoreEmoji} ${analysis.name} (Score: ${analysis.score}/100)`);
+  console.log(`   Path: ${analysis.path}`);
+  if (analysis.issues.length > 0) {
+    console.log("\n   Issues:");
+    analysis.issues.forEach((issue) => console.log(`   \u274C ${issue}`));
+  }
+  if (analysis.suggestions.length > 0) {
+    console.log("\n   Suggestions:");
+    analysis.suggestions.forEach((suggestion) => console.log(`   \u{1F4A1} ${suggestion}`));
+  }
+  if (analysis.issues.length === 0 && analysis.suggestions.length === 0) {
+    console.log("   This skill looks great!");
+  }
+}
+function analyzeCommand(program2) {
+  program2.command("analyze").description("Analyze existing skills and suggest improvements").option("-s, --skill <name>", "Analyze a specific skill").action((options) => {
+    const skillsDir = join(process.cwd(), ".github", "skills");
+    if (!existsSync(skillsDir)) {
+      console.log("\u274C No skills found at .github/skills/");
+      console.log('   Run "npx mother-brain init" first to install skills.');
+      return;
+    }
+    const skills = readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    if (skills.length === 0) {
+      console.log("\u274C No skills found in .github/skills/");
+      return;
+    }
+    const targetSkills = options.skill ? skills.filter((s) => s === options.skill) : skills;
+    if (options.skill && targetSkills.length === 0) {
+      console.log(`\u274C Skill "${options.skill}" not found`);
+      return;
+    }
+    console.log("\n\u{1F50D} Analyzing skills...\n");
+    console.log("\u2501".repeat(50));
+    const analyses = [];
+    for (const skillName of targetSkills) {
+      const skillPath = join(skillsDir, skillName);
+      const analysis = analyzeSkill(skillPath, skillName);
+      analyses.push(analysis);
+      printAnalysis(analysis);
+    }
+    console.log("\n" + "\u2501".repeat(50));
+    const avgScore = Math.round(analyses.reduce((sum, a) => sum + a.score, 0) / analyses.length);
+    const totalIssues = analyses.reduce((sum, a) => sum + a.issues.length, 0);
+    const totalSuggestions = analyses.reduce((sum, a) => sum + a.suggestions.length, 0);
+    console.log(`
+\u{1F4CA} Summary:`);
+    console.log(`   Skills analyzed: ${analyses.length}`);
+    console.log(`   Average score: ${avgScore}/100`);
+    console.log(`   Total issues: ${totalIssues}`);
+    console.log(`   Total suggestions: ${totalSuggestions}`);
+    if (totalIssues > 0 || totalSuggestions > 0) {
+      console.log(`
+\u{1F4A1} Run "npx mother-brain upgrade <skill-name>" to apply improvements`);
+    }
+  });
+}
+
+// src/commands/upgrade.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import chalk4 from "chalk";
+import readline from "readline";
+function generateImprovements(skillPath) {
+  const skillMdPath = join2(skillPath, "SKILL.md");
+  const improvements = [];
+  if (!existsSync2(skillMdPath)) {
+    return improvements;
+  }
+  const content = readFileSync2(skillMdPath, "utf-8");
+  if (!/^---\r?\n[\s\S]*?\r?\n---/m.test(content)) {
+    improvements.push({
+      type: "add",
+      section: "Frontmatter",
+      description: "Add YAML frontmatter with skill metadata",
+      template: `---
+name: ${extractSkillName(content)}
+description: [Add description]
+allowed-tools: powershell view grep glob create edit ask_user
+---
+
+`
+    });
+  }
+  if (!/^##?\s*Purpose/im.test(content)) {
+    improvements.push({
+      type: "add",
+      section: "Purpose",
+      description: "Add Purpose section explaining what the skill does",
+      template: `
+## Purpose
+
+[Describe what this skill does and when to use it]
+
+`
+    });
+  }
+  if (!/^##?\s*Steps/im.test(content)) {
+    improvements.push({
+      type: "add",
+      section: "Steps",
+      description: "Add Steps section with structured workflow",
+      template: `
+## Steps
+
+### 1. [First Step]
+- [Details]
+
+### 2. [Second Step]
+- [Details]
+
+`
+    });
+  }
+  if (!/wizard|ask_user|choices/i.test(content)) {
+    improvements.push({
+      type: "add",
+      section: "Wizard Pattern",
+      description: "Add wizard-style user prompts for better interaction",
+      template: `
+### User Interaction Pattern
+
+Use \`ask_user\` tool with choices for all user decisions:
+- Provide 2-3 clear options
+- Allow freeform for custom inputs
+- Never ask yes/no in plain text
+
+`
+    });
+  }
+  if (!/validation|verify|check/i.test(content)) {
+    improvements.push({
+      type: "add",
+      section: "Validation",
+      description: "Add validation steps to verify output quality",
+      template: `
+### Validation
+
+Before marking complete:
+- [ ] Output matches requirements
+- [ ] User has reviewed and approved
+- [ ] No errors in execution
+
+`
+    });
+  }
+  return improvements;
+}
+function extractSkillName(content) {
+  const match = content.match(/^#\s*(.+)$/m);
+  if (match) {
+    return match[1].toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").substring(0, 30);
+  }
+  return "unnamed-skill";
+}
+async function promptUser(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+function upgradeCommand(program2) {
+  program2.command("upgrade [skill]").description("Apply improvements to a skill based on analysis").option("-a, --all", "Upgrade all skills").option("-y, --yes", "Accept all improvements without prompting").action(async (skillName, options) => {
+    const skillsDir = join2(process.cwd(), ".github", "skills");
+    if (!existsSync2(skillsDir)) {
+      console.log(chalk4.red("\u274C No skills found at .github/skills/"));
+      console.log('   Run "npx mother-brain init" first.');
+      return;
+    }
+    if (!skillName && !options.all) {
+      console.log(chalk4.yellow("Usage: mother-brain upgrade <skill-name>"));
+      console.log(chalk4.yellow("   or: mother-brain upgrade --all"));
+      return;
+    }
+    const skills = options.all ? __require("fs").readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [skillName];
+    let totalApplied = 0;
+    let totalSkipped = 0;
+    for (const skill of skills) {
+      const skillPath = join2(skillsDir, skill);
+      if (!existsSync2(skillPath)) {
+        console.log(chalk4.red(`\u274C Skill "${skill}" not found`));
+        continue;
+      }
+      console.log(chalk4.cyan(`
+\u{1F527} Upgrading: ${skill}`));
+      console.log("\u2500".repeat(40));
+      const improvements = generateImprovements(skillPath);
+      if (improvements.length === 0) {
+        console.log(chalk4.green("\u2705 No improvements needed"));
+        continue;
+      }
+      const skillMdPath = join2(skillPath, "SKILL.md");
+      let content = readFileSync2(skillMdPath, "utf-8");
+      for (const improvement of improvements) {
+        console.log(`
+${chalk4.yellow("\u{1F4A1}")} ${improvement.description}`);
+        console.log(chalk4.dim(`   Section: ${improvement.section}`));
+        console.log(chalk4.dim(`   Preview:`));
+        const previewLines = improvement.template.split("\n").slice(0, 5);
+        previewLines.forEach((line) => console.log(chalk4.dim(`   ${line}`)));
+        if (improvement.template.split("\n").length > 5) {
+          console.log(chalk4.dim("   ..."));
+        }
+        let action = "a";
+        if (!options.yes) {
+          console.log(`
+   ${chalk4.green("[a]")}ccept  ${chalk4.yellow("[s]")}kip  ${chalk4.blue("[t]")}weak`);
+          action = await promptUser("   Choice: ");
+        }
+        if (action === "a" || action === "accept" || action === "") {
+          if (improvement.section === "Frontmatter") {
+            content = improvement.template + content;
+          } else {
+            content = content.trimEnd() + "\n" + improvement.template;
+          }
+          console.log(chalk4.green("   \u2705 Applied"));
+          totalApplied++;
+        } else if (action === "t" || action === "tweak") {
+          console.log(chalk4.yellow("   \u{1F4DD} Tweaking is available in interactive mode"));
+          console.log(chalk4.yellow("      For now, edit the skill manually after upgrade"));
+          totalSkipped++;
+        } else {
+          console.log(chalk4.dim("   \u23ED\uFE0F Skipped"));
+          totalSkipped++;
+        }
+      }
+      writeFileSync(skillMdPath, content);
+      console.log(chalk4.green(`
+\u2705 ${skill} saved`));
+    }
+    console.log(chalk4.cyan("\n" + "\u2550".repeat(40)));
+    console.log(chalk4.white(`\u{1F4CA} Summary:`));
+    console.log(`   Applied: ${totalApplied} improvements`);
+    console.log(`   Skipped: ${totalSkipped}`);
+    if (totalApplied > 0) {
+      console.log(chalk4.green("\n\u2705 Skills upgraded! Review changes before committing."));
+    }
+  });
+}
+
+// src/cli.ts
+import { exec as exec3 } from "child_process";
+var program = new Command();
+var VERSION = "0.0.7";
+program.name("mother-brain").description("AI-powered project management framework for GitHub Copilot CLI").version(VERSION);
+program.command("init").description("Initialize Mother Brain in the current project").option("-f, --force", "Overwrite existing skills").action(init);
+program.command("update").description("Update Mother Brain skills to the latest version").action(update);
+program.command("status").description("Show installed version and available updates").action(status);
+analyzeCommand(program);
+upgradeCommand(program);
+program.command("docs").description("Open Mother Brain documentation in browser").action(() => {
+  const url = "https://github.com/super-state/mother-brain#readme";
+  console.log(chalk5.cyan("\u{1F4D6} Opening documentation..."));
+  const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+  exec3(`${cmd} ${url}`, (err) => {
+    if (err) {
+      console.log(chalk5.yellow(`
+Couldn't open browser. Visit: ${url}`));
+    }
+  });
+});
+program.command("quickstart").description("Show quick start guide").action(() => {
+  console.log(chalk5.cyan(`
+\u2533\u2533\u2513\u250F\u2513\u250F\u2533\u2513\u2513\u250F\u250F\u2513\u2533\u2513  \u2533\u2513\u2533\u2513\u250F\u2513\u2533\u2533\u2513
+\u2503\u2503\u2503\u2503\u2503 \u2503 \u2523\u252B\u2523 \u2523\u252B  \u2523\u252B\u2523\u252B\u2523\u252B\u2503\u2503\u2503
+\u251B \u2517\u2517\u251B \u253B \u251B\u2517\u2517\u251B\u251B\u2517  \u253B\u251B\u251B\u2517\u251B\u2517\u253B\u251B\u2517
+`));
+  console.log(chalk5.white.bold("\u{1F680} Quick Start Guide\n"));
+  console.log(chalk5.yellow("Step 1:") + " Initialize Mother Brain in your project");
+  console.log(chalk5.dim("  npx mother-brain init\n"));
+  console.log(chalk5.yellow("Step 2:") + " Start using it with GitHub Copilot CLI");
+  console.log(chalk5.dim('  ghcs "/mother-brain"\n'));
+  console.log(chalk5.yellow("Step 3:") + " Follow the wizard to define your vision");
+  console.log(chalk5.dim("  Mother Brain will guide you through:\n"));
+  console.log(chalk5.dim("  - Vision Discovery (what are you building?)"));
+  console.log(chalk5.dim("  - Roadmap Generation (how to get there)"));
+  console.log(chalk5.dim("  - Skill Creation (automate repetitive tasks)"));
+  console.log(chalk5.dim("  - Task Execution (build it step by step)\n"));
+  console.log(chalk5.green("That's it!") + " Mother Brain will help you ship faster.\n");
+  console.log(chalk5.dim("For more info: mother-brain docs"));
+});
+program.action(() => {
+  console.log(chalk5.cyan(`
+\u2533\u2533\u2513\u250F\u2513\u250F\u2533\u2513\u2513\u250F\u250F\u2513\u2533\u2513  \u2533\u2513\u2533\u2513\u250F\u2513\u2533\u2533\u2513
+\u2503\u2503\u2503\u2503\u2503 \u2503 \u2523\u252B\u2523 \u2523\u252B  \u2523\u252B\u2523\u252B\u2523\u252B\u2503\u2503\u2503
+\u251B \u2517\u2517\u251B \u253B \u251B\u2517\u2517\u251B\u251B\u2517  \u253B\u251B\u251B\u2517\u251B\u2517\u253B\u251B\u2517
+`));
+  console.log(chalk5.white("AI-powered project management for GitHub Copilot CLI"));
+  console.log(chalk5.dim(`v${VERSION}
+`));
+  console.log(chalk5.white.bold("Getting Started:"));
+  console.log(chalk5.green("  npx mother-brain init       ") + "Add to your project");
+  console.log(chalk5.green("  npx mother-brain quickstart ") + "Show quick start guide\n");
+  console.log(chalk5.white.bold("Commands:"));
+  console.log(chalk5.green("  init       ") + "Add Mother Brain skills to project");
+  console.log(chalk5.green("  update     ") + "Update to the latest version");
+  console.log(chalk5.green("  status     ") + "Check installed version");
+  console.log(chalk5.green("  analyze    ") + "Analyze skills and suggest improvements");
+  console.log(chalk5.green("  upgrade    ") + "Apply improvements to skills");
+  console.log(chalk5.green("  docs       ") + "Open documentation in browser");
+  console.log(chalk5.green("  quickstart ") + "Show quick start guide\n");
+  console.log(chalk5.dim("Run mother-brain <command> --help for command details"));
+});
+program.parse();

package/package.json

@@ -1,22 +1,48 @@
-{
-  "name": "mother-brain",
-  "version": "0.0.5",
-  "description": "Vision-driven project framework that guides discovery, creates roadmaps, auto-generates skills, and manages task execution.",
-  "license": "MIT",
-  "bin": {
-    "mother-brain": "bin/mother-brain.js"
-  },
-  "files": [
-    "bin/",
-    ".github/skills/",
-    "docs/",
-    "assets/",
-    "README.md",
-    "LICENSE",
-    "CODE_OF_CONDUCT.md",
-    "CONTRIBUTING.md"
-  ],
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "mother-brain",
+  "version": "0.0.7",
+  "description": "AI-powered project management framework for GitHub Copilot CLI",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mother-brain": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/cli.ts --format esm --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mother-brain",
+    "github-copilot",
+    "cli",
+    "ai",
+    "project-management",
+    "skills"
+  ],
+  "author": "super-state",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/super-state/mother-brain.git",
+    "directory": "cli"
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  }
+}