workflow-agent-cli 1.1.2

package/dist/cli/index.js

@@ -0,0 +1,1206 @@
+#!/usr/bin/env node
+import {
+  validateBranchName,
+  validateCommitMessage,
+  validatePRTitle
+} from "../chunk-X2NQJ2ZY.js";
+import {
+  hasConfig,
+  loadConfig,
+  validateScopeDefinitions
+} from "../chunk-VFN3BY56.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { existsSync } from "fs";
+import { writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/templates/renderer.ts
+import fs from "fs/promises";
+import path from "path";
+
+// src/adapters/index.ts
+var adapters = {
+  "nextjs-app-router": {
+    name: "Next.js App Router",
+    description: "Next.js 13+ with app directory",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("app") && fs2.existsSync("next.config.ts") || fs2.existsSync("next.config.js");
+    },
+    paths: {
+      actions: "app/actions",
+      components: "components",
+      lib: "lib",
+      hooks: "hooks",
+      types: "types",
+      tests: "__tests__",
+      config: "app"
+    }
+  },
+  "nextjs-pages": {
+    name: "Next.js Pages Router",
+    description: "Next.js with pages directory",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("pages") && (fs2.existsSync("next.config.ts") || fs2.existsSync("next.config.js"));
+    },
+    paths: {
+      components: "components",
+      lib: "lib",
+      hooks: "hooks",
+      types: "types",
+      tests: "__tests__",
+      config: "pages"
+    }
+  },
+  "vite-react": {
+    name: "Vite + React",
+    description: "Vite-powered React application",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("vite.config.ts") || fs2.existsSync("vite.config.js");
+    },
+    paths: {
+      components: "src/components",
+      lib: "src/lib",
+      hooks: "src/hooks",
+      types: "src/types",
+      tests: "src/__tests__",
+      config: "src"
+    }
+  },
+  "remix": {
+    name: "Remix",
+    description: "Remix full-stack framework",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("app/routes") && (fs2.existsSync("remix.config.js") || fs2.existsSync("package.json"));
+    },
+    paths: {
+      components: "app/components",
+      lib: "app/lib",
+      types: "app/types",
+      tests: "app/__tests__",
+      config: "app/root.tsx"
+    }
+  },
+  "astro": {
+    name: "Astro",
+    description: "Astro static site framework",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("astro.config.mjs") || fs2.existsSync("astro.config.ts");
+    },
+    paths: {
+      components: "src/components",
+      lib: "src/lib",
+      types: "src/types",
+      tests: "src/__tests__",
+      config: "src/pages"
+    }
+  },
+  "sveltekit": {
+    name: "SvelteKit",
+    description: "SvelteKit full-stack framework",
+    detect: async () => {
+      const fs2 = await import("fs");
+      return fs2.existsSync("svelte.config.js") || fs2.existsSync("src/routes");
+    },
+    paths: {
+      components: "src/lib/components",
+      lib: "src/lib",
+      types: "src/lib/types",
+      tests: "src/lib/__tests__",
+      config: "src/routes"
+    }
+  },
+  "generic": {
+    name: "Generic Project",
+    description: "Standard project structure",
+    detect: async () => true,
+    // Always matches as fallback
+    paths: {
+      components: "src/components",
+      lib: "src/lib",
+      types: "src/types",
+      tests: "tests",
+      config: "src"
+    }
+  }
+};
+async function detectAdapter() {
+  for (const [key, adapter] of Object.entries(adapters)) {
+    if (key === "generic") continue;
+    try {
+      if (await adapter.detect()) {
+        return key;
+      }
+    } catch {
+    }
+  }
+  return "generic";
+}
+function getAdapter(name) {
+  return adapters[name] || null;
+}
+
+// src/templates/renderer.ts
+function renderTemplate(template, context) {
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return context[key] ?? match;
+  });
+}
+async function buildTemplateContext(config, projectPath = process.cwd()) {
+  const detectedFramework = await detectAdapter();
+  const adapter = getAdapter(detectedFramework);
+  const scopeList = config.scopes.map((s) => `- **${s.name}** - ${s.description}`).join("\n");
+  const scopes = config.scopes.map((s) => s.name).join(", ");
+  const pathStructure = adapter ? `
+### Path Structure
+
+\`\`\`
+${adapter.paths.components}/    \u2192 UI components
+${adapter.paths.lib}/          \u2192 Utility functions and services
+${adapter.paths.hooks}/        \u2192 Custom React hooks
+${adapter.paths.types}/        \u2192 TypeScript type definitions
+\`\`\`
+`.trim() : "N/A";
+  const projectName = await getProjectName(projectPath);
+  return {
+    projectName,
+    framework: adapter?.name || "unknown",
+    scopes,
+    scopeList,
+    pathStructure,
+    enforcement: config.enforcement,
+    year: (/* @__PURE__ */ new Date()).getFullYear().toString()
+  };
+}
+async function renderTemplateFile(templatePath, outputPath, context) {
+  const template = await fs.readFile(templatePath, "utf-8");
+  const rendered = renderTemplate(template, context);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, rendered, "utf-8");
+}
+async function renderTemplateDirectory(templateDir, outputDir, context) {
+  const files = await fs.readdir(templateDir);
+  const rendered = [];
+  for (const file of files) {
+    if (!file.match(/\.(md|ts|json)$/)) continue;
+    const templatePath = path.join(templateDir, file);
+    const outputPath = path.join(outputDir, file);
+    await renderTemplateFile(templatePath, outputPath, context);
+    rendered.push(file);
+  }
+  return rendered;
+}
+async function getProjectName(projectPath) {
+  try {
+    const pkgPath = path.join(projectPath, "package.json");
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+    return pkg.name || path.basename(projectPath);
+  } catch {
+    return path.basename(projectPath);
+  }
+}
+async function validateTemplateDirectory(templateDir) {
+  try {
+    const stat = await fs.stat(templateDir);
+    if (!stat.isDirectory()) {
+      throw new Error(`Template path is not a directory: ${templateDir}`);
+    }
+    const files = await fs.readdir(templateDir);
+    const templateFiles = files.filter((f) => f.match(/\.(md|ts|json)$/));
+    if (templateFiles.length === 0) {
+      throw new Error(`No template files found in template directory: ${templateDir}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Template directory not found: ${templateDir}`);
+    }
+    throw error;
+  }
+}
+
+// src/cli/commands/init.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+async function initCommand(options) {
+  console.log(chalk.bold.cyan("\n\u{1F680} Workflow Agent Initialization\n"));
+  const cwd = process.cwd();
+  const isNonInteractive = !!(options.preset && options.name);
+  if (hasConfig(cwd) && !options.yes && !isNonInteractive) {
+    const shouldContinue = await p.confirm({
+      message: "Workflow Agent is already configured. Continue and overwrite?",
+      initialValue: false
+    });
+    if (p.isCancel(shouldContinue) || !shouldContinue) {
+      p.cancel("Initialization cancelled");
+      process.exit(0);
+    }
+  }
+  const projectName = isNonInteractive ? options.name : await p.text({
+    message: "What is your project name?",
+    placeholder: "my-awesome-project",
+    defaultValue: process.cwd().split("/").pop() || "my-project"
+  });
+  if (!isNonInteractive && p.isCancel(projectName)) {
+    p.cancel("Initialization cancelled");
+    process.exit(0);
+  }
+  const preset = isNonInteractive ? options.preset : await p.select({
+    message: "Choose a scope preset for your project:",
+    options: [
+      { value: "saas", label: "\u{1F4E6} SaaS Application - 17 scopes (auth, tasks, boards, sprints, etc.)" },
+      { value: "library", label: "\u{1F4DA} Library/Package - 10 scopes (types, build, docs, examples, etc.)" },
+      { value: "api", label: "\u{1F50C} API/Backend - 13 scopes (auth, endpoints, models, services, etc.)" },
+      { value: "ecommerce", label: "\u{1F6D2} E-commerce - 12 scopes (cart, products, payments, orders, etc.)" },
+      { value: "cms", label: "\u{1F4DD} CMS - 13 scopes (content, pages, media, editor, etc.)" },
+      { value: "custom", label: "\u2728 Custom (define your own scopes manually)" }
+    ]
+  });
+  if (!isNonInteractive && p.isCancel(preset)) {
+    p.cancel("Initialization cancelled");
+    process.exit(0);
+  }
+  let scopes = [];
+  if (preset !== "custom") {
+    try {
+      const presetModule = await import(`@workflow/scopes-${preset}`);
+      scopes = presetModule.scopes || presetModule.default.scopes;
+      const spinner4 = p.spinner();
+      spinner4.start(`Loading ${presetModule.default?.name || preset} preset`);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      spinner4.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
+    } catch (error) {
+      console.log(chalk.yellow(`
+\u26A0\uFE0F  Could not load preset package. Using basic scopes.`));
+      scopes = [
+        { name: "feat", description: "New features", emoji: "\u2728" },
+        { name: "fix", description: "Bug fixes", emoji: "\u{1F41B}" },
+        { name: "docs", description: "Documentation", emoji: "\u{1F4DA}" }
+      ];
+    }
+  } else {
+    scopes = [
+      { name: "feat", description: "New features", emoji: "\u2728" },
+      { name: "fix", description: "Bug fixes", emoji: "\u{1F41B}" },
+      { name: "docs", description: "Documentation", emoji: "\u{1F4DA}" }
+    ];
+    console.log(chalk.dim("\n\u{1F4A1} Tip: Edit workflow.config.json to add your custom scopes"));
+  }
+  const config = {
+    projectName,
+    scopes,
+    enforcement: "strict",
+    language: "en"
+  };
+  const configPath = join(cwd, "workflow.config.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  const workflowDir = join(cwd, ".workflow");
+  if (!existsSync(workflowDir)) {
+    await mkdir(workflowDir, { recursive: true });
+  }
+  const shouldGenerateGuidelines = await p.confirm({
+    message: "Generate workflow guidelines from templates?",
+    initialValue: true
+  });
+  if (p.isCancel(shouldGenerateGuidelines)) {
+    p.cancel("Initialization cancelled");
+    process.exit(0);
+  }
+  if (shouldGenerateGuidelines) {
+    const spinner4 = p.spinner();
+    spinner4.start("Generating guidelines...");
+    try {
+      const templatesDir = join(__dirname, "../../../templates");
+      await validateTemplateDirectory(templatesDir);
+      const context = await buildTemplateContext(config, cwd);
+      const guidelinesDir = join(cwd, "guidelines");
+      await mkdir(guidelinesDir, { recursive: true });
+      const renderedFiles = await renderTemplateDirectory(templatesDir, guidelinesDir, context);
+      spinner4.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
+    } catch (error) {
+      spinner4.stop("\u26A0\uFE0F  Could not generate guidelines");
+      console.log(chalk.yellow(`
+Reason: ${error instanceof Error ? error.message : String(error)}`));
+      console.log(chalk.dim("You can manually copy guidelines later if needed."));
+    }
+  }
+  p.outro(chalk.green("\u2713 Workflow Agent initialized successfully!"));
+  console.log(chalk.dim("\nNext steps:"));
+  console.log(chalk.dim("  1. Review your configuration in workflow.config.json"));
+  if (shouldGenerateGuidelines) {
+    console.log(chalk.dim("  2. Review generated guidelines in guidelines/ directory"));
+    console.log(chalk.dim("  3. Run: workflow validate branch"));
+    console.log(chalk.dim("  4. Run: workflow doctor (for optimization suggestions)\n"));
+  } else {
+    console.log(chalk.dim("  2. Run: workflow validate branch"));
+    console.log(chalk.dim("  3. Run: workflow doctor (for optimization suggestions)\n"));
+  }
+}
+
+// src/cli/commands/validate.ts
+import chalk2 from "chalk";
+import { execa } from "execa";
+async function validateCommand(type, value, _options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    console.error(chalk2.red("\u2717 No workflow configuration found. Run: workflow init"));
+    process.exit(1);
+  }
+  let targetValue = value;
+  try {
+    let result;
+    switch (type) {
+      case "branch": {
+        if (!targetValue) {
+          const { stdout } = await execa("git", ["branch", "--show-current"]);
+          targetValue = stdout.trim();
+        }
+        result = await validateBranchName(targetValue, config);
+        break;
+      }
+      case "commit": {
+        if (!targetValue) {
+          const { stdout } = await execa("git", ["log", "-1", "--pretty=%s"]);
+          targetValue = stdout.trim();
+        }
+        result = await validateCommitMessage(targetValue, config);
+        break;
+      }
+      case "pr":
+      case "pr-title": {
+        if (!targetValue) {
+          console.error(chalk2.red("\u2717 PR title must be provided as argument"));
+          process.exit(1);
+        }
+        result = await validatePRTitle(targetValue, config);
+        break;
+      }
+      default:
+        console.error(chalk2.red(`\u2717 Unknown validation type: ${type}`));
+        console.error(chalk2.dim("Valid types: branch, commit, pr"));
+        process.exit(1);
+    }
+    if (result.valid) {
+      console.log(chalk2.green(`\u2713 ${type} is valid: ${targetValue}`));
+      process.exit(0);
+    } else {
+      console.error(chalk2.red(`\u2717 Invalid ${type}: ${targetValue}`));
+      console.error(chalk2.yellow(`  ${result.error}`));
+      if (result.suggestion) {
+        console.error(chalk2.cyan(`  \u{1F4A1} ${result.suggestion}`));
+      }
+      const enforcementLevel = config.enforcement;
+      if (enforcementLevel === "strict") {
+        process.exit(1);
+      } else {
+        console.log(chalk2.yellow(`
+\u26A0\uFE0F  Advisory mode: validation failed but not blocking`));
+        process.exit(0);
+      }
+    }
+  } catch (error) {
+    console.error(chalk2.red(`\u2717 Validation error: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/config.ts
+import chalk3 from "chalk";
+async function configCommand(action, key, value) {
+  console.log(chalk3.yellow("Config command not yet implemented"));
+  console.log({ action, key, value });
+}
+
+// src/cli/commands/suggest.ts
+import chalk4 from "chalk";
+import * as p2 from "@clack/prompts";
+import { createTracker } from "@hawkinside_out/workflow-improvement-tracker";
+async function suggestCommand(feedback, options = {}) {
+  console.log(chalk4.cyan("\u{1F4A1} Submitting improvement suggestion...\n"));
+  const tracker = createTracker();
+  let category = options.category;
+  if (!category) {
+    const categoryChoice = await p2.select({
+      message: "What type of improvement is this?",
+      options: [
+        { value: "feature", label: "\u2728 Feature Request" },
+        { value: "bug", label: "\u{1F41B} Bug Report" },
+        { value: "documentation", label: "\u{1F4DA} Documentation" },
+        { value: "performance", label: "\u26A1 Performance" },
+        { value: "other", label: "\u{1F4A1} Other" }
+      ]
+    });
+    if (p2.isCancel(categoryChoice)) {
+      p2.cancel("Suggestion cancelled");
+      process.exit(0);
+    }
+    category = categoryChoice;
+  }
+  const result = await tracker.submit(feedback, options.author, category);
+  if (!result.success) {
+    console.log(chalk4.red("\u2717 Suggestion rejected"));
+    console.log(chalk4.dim(`  Reason: ${result.error}`));
+    process.exit(1);
+  }
+  console.log(chalk4.green("\u2713 Suggestion submitted successfully!"));
+  console.log(chalk4.dim(`  ID: ${result.suggestion?.id}`));
+  console.log(chalk4.dim(`  Status: ${result.suggestion?.status}`));
+  console.log(chalk4.dim(`  Category: ${result.suggestion?.category}`));
+  console.log(chalk4.dim("\nYour suggestion will be:"));
+  console.log(chalk4.dim("  1. Reviewed by the community"));
+  console.log(chalk4.dim("  2. Prioritized based on impact"));
+  console.log(chalk4.dim("  3. Incorporated into future releases if approved\n"));
+}
+
+// src/cli/commands/doctor.ts
+import chalk5 from "chalk";
+async function doctorCommand() {
+  console.log(chalk5.bold.cyan("\n\u{1F3E5} Workflow Agent Health Check\n"));
+  const config = await loadConfig();
+  if (!config) {
+    console.error(chalk5.red("\u2717 No workflow configuration found"));
+    console.log(chalk5.yellow("  Run: workflow init"));
+    process.exit(1);
+  }
+  console.log(chalk5.green("\u2713 Configuration loaded successfully"));
+  console.log(chalk5.dim(`  Project: ${config.projectName}`));
+  console.log(chalk5.dim(`  Scopes: ${config.scopes.length} configured`));
+  console.log(chalk5.dim(`  Enforcement: ${config.enforcement}`));
+  console.log(chalk5.dim(`  Language: ${config.language}`));
+  console.log(chalk5.cyan("\n\u{1F4A1} Suggestions:\n"));
+  console.log(chalk5.dim("  \u2022 Health check analysis coming soon"));
+  console.log(chalk5.dim("  \u2022 Git history analysis coming soon"));
+  console.log(chalk5.dim("  \u2022 Optimization recommendations coming soon"));
+}
+
+// src/cli/commands/setup.ts
+import * as p3 from "@clack/prompts";
+import chalk6 from "chalk";
+import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var WORKFLOW_SCRIPTS = {
+  "workflow:init": "workflow-agent init",
+  "workflow:validate": "workflow-agent validate",
+  "workflow:suggest": "workflow-agent suggest",
+  "workflow:doctor": "workflow-agent doctor"
+};
+async function setupCommand() {
+  p3.intro(chalk6.bgBlue(" workflow-agent setup "));
+  const cwd = process.cwd();
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    p3.cancel("No package.json found in current directory");
+    process.exit(1);
+  }
+  const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+  const packageJson = JSON.parse(packageJsonContent);
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  const existingScripts = [];
+  const scriptsToAdd = {};
+  for (const [scriptName, scriptCommand] of Object.entries(WORKFLOW_SCRIPTS)) {
+    if (packageJson.scripts[scriptName]) {
+      existingScripts.push(scriptName);
+    } else {
+      scriptsToAdd[scriptName] = scriptCommand;
+    }
+  }
+  if (Object.keys(scriptsToAdd).length === 0) {
+    p3.outro(chalk6.green("\u2713 All workflow scripts are already configured!"));
+    return;
+  }
+  console.log(chalk6.dim("\nScripts to add:"));
+  for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
+    console.log(chalk6.dim(`  ${scriptName}: ${scriptCommand}`));
+  }
+  if (existingScripts.length > 0) {
+    console.log(chalk6.yellow("\nExisting scripts (will be skipped):"));
+    existingScripts.forEach((name) => {
+      console.log(chalk6.yellow(`  ${name}`));
+    });
+  }
+  const shouldAdd = await p3.confirm({
+    message: "Add these scripts to package.json?",
+    initialValue: true
+  });
+  if (p3.isCancel(shouldAdd) || !shouldAdd) {
+    p3.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
+    packageJson.scripts[scriptName] = scriptCommand;
+  }
+  writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + "\n",
+    "utf-8"
+  );
+  p3.outro(chalk6.green(`\u2713 Added ${Object.keys(scriptsToAdd).length} workflow scripts to package.json!`));
+  console.log(chalk6.dim("\nRun them with:"));
+  console.log(chalk6.dim("  pnpm run workflow:init"));
+  console.log(chalk6.dim("  npm run workflow:init\n"));
+}
+
+// src/cli/commands/scope-create.ts
+import * as p4 from "@clack/prompts";
+import chalk7 from "chalk";
+import { existsSync as existsSync3 } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2, readFile } from "fs/promises";
+import { join as join3 } from "path";
+async function scopeCreateCommand(options) {
+  console.log(chalk7.bold.cyan("\n\u{1F3A8} Create Custom Scope Package\n"));
+  const cwd = process.cwd();
+  const isNonInteractive = !!(options.name && options.scopes && options.presetName);
+  const isMonorepo = existsSync3(join3(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo) {
+    console.log(chalk7.dim("\u2713 Detected monorepo workspace\n"));
+  }
+  const packageNameInput = isNonInteractive ? options.name : await p4.text({
+    message: 'What is the package name? (e.g., "fintech", "gaming", "healthcare")',
+    placeholder: "my-custom-scope",
+    validate: (value) => {
+      if (!value || value.length === 0) return "Package name is required";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Package name must be lowercase alphanumeric with hyphens";
+      if (value.length > 32) return "Package name must be 32 characters or less";
+      return void 0;
+    }
+  });
+  if (!isNonInteractive && p4.isCancel(packageNameInput)) {
+    p4.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const packageName = packageNameInput;
+  const presetNameInput = isNonInteractive ? options.presetName : await p4.text({
+    message: 'What is the preset display name? (e.g., "FinTech Application", "Gaming Platform")',
+    placeholder: "My Custom Preset",
+    validate: (value) => {
+      if (!value || value.length === 0) return "Preset name is required";
+      return void 0;
+    }
+  });
+  if (!isNonInteractive && p4.isCancel(presetNameInput)) {
+    p4.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const presetName = presetNameInput;
+  const scopes = [];
+  if (isNonInteractive && options.scopes) {
+    const scopeParts = options.scopes.split(",");
+    for (const part of scopeParts) {
+      const [name, description, emoji, category] = part.split(":");
+      scopes.push({
+        name: name.trim(),
+        description: description?.trim() || "Scope description",
+        emoji: emoji?.trim(),
+        category: category?.trim()
+      });
+    }
+  } else {
+    console.log(chalk7.dim("\nAdd scopes to your preset (aim for 8-15 scopes):\n"));
+    let addMore = true;
+    while (addMore) {
+      const scopeName = await p4.text({
+        message: `Scope #${scopes.length + 1} - Name:`,
+        placeholder: "auth",
+        validate: (value) => {
+          if (!value || value.length === 0) return "Scope name is required";
+          if (!/^[a-z0-9-]+$/.test(value)) return "Must be lowercase alphanumeric with hyphens";
+          if (value.length > 32) return "Must be 32 characters or less";
+          if (scopes.some((s) => s.name === value)) return "Scope name already exists";
+          return void 0;
+        }
+      });
+      if (p4.isCancel(scopeName)) {
+        break;
+      }
+      const scopeDescription = await p4.text({
+        message: "Description:",
+        placeholder: "Authentication and authorization",
+        validate: (value) => {
+          if (!value || value.length < 10) return "Description must be at least 10 characters";
+          return void 0;
+        }
+      });
+      if (p4.isCancel(scopeDescription)) {
+        break;
+      }
+      const scopeEmoji = await p4.text({
+        message: "Emoji (optional):",
+        placeholder: "\u{1F510}"
+      });
+      if (p4.isCancel(scopeEmoji)) {
+        break;
+      }
+      const scopeCategory = await p4.select({
+        message: "Category (optional):",
+        options: [
+          { value: "auth", label: "Authentication & Authorization" },
+          { value: "features", label: "Features & Functionality" },
+          { value: "infrastructure", label: "Infrastructure & DevOps" },
+          { value: "documentation", label: "Documentation" },
+          { value: "testing", label: "Testing & QA" },
+          { value: "performance", label: "Performance & Optimization" },
+          { value: "other", label: "Other" },
+          { value: "", label: "None" }
+        ]
+      });
+      if (p4.isCancel(scopeCategory)) {
+        break;
+      }
+      scopes.push({
+        name: scopeName,
+        description: scopeDescription,
+        emoji: scopeEmoji ? scopeEmoji : void 0,
+        category: scopeCategory ? scopeCategory : void 0
+      });
+      console.log(chalk7.green(`
+\u2713 Added scope: ${scopeName}
+`));
+      if (scopes.length >= 3) {
+        addMore = await p4.confirm({
+          message: `You have ${scopes.length} scopes. Add another?`,
+          initialValue: scopes.length < 10
+        });
+        if (p4.isCancel(addMore)) {
+          break;
+        }
+        if (!addMore) break;
+      }
+    }
+  }
+  if (scopes.length === 0) {
+    p4.cancel("No scopes defined. Operation cancelled.");
+    process.exit(1);
+  }
+  const validation = validateScopeDefinitions(scopes);
+  if (!validation.valid) {
+    console.log(chalk7.red("\n\u2717 Scope validation failed:\n"));
+    validation.errors.forEach((error) => console.log(chalk7.red(`  \u2022 ${error}`)));
+    p4.cancel("Operation cancelled");
+    process.exit(1);
+  }
+  console.log(chalk7.green(`
+\u2713 ${scopes.length} scopes validated successfully
+`));
+  let outputDir;
+  if (options.outputDir) {
+    outputDir = options.outputDir;
+  } else if (isMonorepo) {
+    outputDir = join3(cwd, "packages", `scopes-${packageName}`);
+  } else {
+    const customDir = await p4.text({
+      message: "Output directory:",
+      placeholder: `./scopes-${packageName}`,
+      defaultValue: `./scopes-${packageName}`
+    });
+    if (p4.isCancel(customDir)) {
+      p4.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    outputDir = join3(cwd, customDir);
+  }
+  if (existsSync3(outputDir)) {
+    const shouldOverwrite = await p4.confirm({
+      message: `Directory ${outputDir} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p4.isCancel(shouldOverwrite) || !shouldOverwrite) {
+      p4.cancel("Operation cancelled");
+      process.exit(0);
+    }
+  }
+  const spinner4 = p4.spinner();
+  spinner4.start("Creating package structure...");
+  try {
+    await mkdir2(join3(outputDir, "src"), { recursive: true });
+    const packageJson = {
+      name: `@workflow/scopes-${packageName}`,
+      version: "1.0.0",
+      description: `Scope preset for ${presetName}`,
+      keywords: ["workflow", "scopes", packageName, "preset"],
+      repository: {
+        type: "git",
+        url: "git+https://github.com/your-org/your-repo.git",
+        directory: `packages/scopes-${packageName}`
+      },
+      license: "MIT",
+      author: "Your Name",
+      type: "module",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        }
+      },
+      files: ["dist"],
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        typecheck: "tsc --noEmit",
+        test: "vitest run"
+      },
+      peerDependencies: {
+        "@hawkinside_out/workflow-agent": "^1.0.0"
+      },
+      devDependencies: {
+        "@hawkinside_out/workflow-agent": "^1.0.0",
+        tsup: "^8.0.1",
+        typescript: "^5.3.3",
+        vitest: "^1.0.0"
+      },
+      publishConfig: {
+        access: "public"
+      }
+    };
+    await writeFile2(
+      join3(outputDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+      "utf-8"
+    );
+    const tsconfig = {
+      extends: "../../tsconfig.json",
+      compilerOptions: {
+        outDir: "./dist",
+        rootDir: "./src"
+      },
+      include: ["src/**/*"]
+    };
+    await writeFile2(
+      join3(outputDir, "tsconfig.json"),
+      JSON.stringify(tsconfig, null, 2),
+      "utf-8"
+    );
+    const tsupConfig = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});
+`;
+    await writeFile2(join3(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    const indexTs = `import type { Scope } from '@hawkinside_out/workflow-agent/config';
+
+export const scopes: Scope[] = ${JSON.stringify(scopes, null, 2)};
+
+export const preset = {
+  name: '${presetName}',
+  description: 'Scope configuration for ${presetName}',
+  scopes,
+  version: '1.0.0',
+};
+
+export default preset;
+`;
+    await writeFile2(join3(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    if (!options.noTest) {
+      const testFile = `import { describe, it, expect } from 'vitest';
+import { scopes, preset } from './index.js';
+import { ScopeSchema } from '@hawkinside_out/workflow-agent/config';
+
+describe('${presetName} Scope Preset', () => {
+  it('should export valid scopes array', () => {
+    expect(scopes).toBeDefined();
+    expect(Array.isArray(scopes)).toBe(true);
+    expect(scopes.length).toBeGreaterThan(0);
+  });
+
+  it('should have valid preset object', () => {
+    expect(preset).toBeDefined();
+    expect(preset.name).toBe('${presetName}');
+    expect(preset.scopes).toBe(scopes);
+    expect(preset.version).toBeDefined();
+  });
+
+  it('should have no duplicate scope names', () => {
+    const names = scopes.map(s => s.name);
+    const uniqueNames = new Set(names);
+    expect(uniqueNames.size).toBe(names.length);
+  });
+
+  it('should have all scopes match schema', () => {
+    scopes.forEach(scope => {
+      const result = ScopeSchema.safeParse(scope);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  it('should have descriptions for all scopes', () => {
+    scopes.forEach(scope => {
+      expect(scope.description).toBeDefined();
+      expect(scope.description.length).toBeGreaterThan(0);
+    });
+  });
+});
+`;
+      await writeFile2(join3(outputDir, "src", "index.test.ts"), testFile, "utf-8");
+    }
+    spinner4.stop("\u2713 Package structure created");
+    if (isMonorepo) {
+      const workspaceFile = join3(cwd, "pnpm-workspace.yaml");
+      const workspaceContent = await readFile(workspaceFile, "utf-8");
+      const packagePath = `packages/scopes-${packageName}`;
+      if (!workspaceContent.includes(packagePath) && !workspaceContent.includes("packages/*")) {
+        console.log(chalk7.yellow("\n\u26A0\uFE0F  Add the following to pnpm-workspace.yaml:"));
+        console.log(chalk7.dim(`  - '${packagePath}'`));
+      } else {
+        console.log(chalk7.green("\n\u2713 Package will be included in workspace"));
+      }
+    }
+    console.log(chalk7.green.bold("\n\u2728 Custom scope package created successfully!\n"));
+    console.log(chalk7.bold("Package details:"));
+    console.log(chalk7.dim(`  Location: ${outputDir}`));
+    console.log(chalk7.dim(`  Package: @workflow/scopes-${packageName}`));
+    console.log(chalk7.dim(`  Scopes: ${scopes.length} defined
+`));
+    console.log(chalk7.bold("Next steps:\n"));
+    console.log(chalk7.dim(`  1. cd ${outputDir}`));
+    console.log(chalk7.dim(`  2. pnpm install`));
+    console.log(chalk7.dim(`  3. pnpm build`));
+    if (!options.noTest) {
+      console.log(chalk7.dim(`  4. pnpm test`));
+    }
+    console.log(chalk7.dim(`  ${!options.noTest ? "5" : "4"}. Update repository URL in package.json`));
+    const shouldPublish = isNonInteractive ? false : await p4.confirm({
+      message: "\nWould you like instructions for publishing to npm?",
+      initialValue: false
+    });
+    if (shouldPublish && !p4.isCancel(shouldPublish)) {
+      console.log(chalk7.bold("\n\u{1F4E6} Publishing instructions:\n"));
+      console.log(chalk7.dim("  1. npm login (or configure .npmrc with your registry)"));
+      console.log(chalk7.dim("  2. Update version in package.json as needed"));
+      console.log(chalk7.dim("  3. pnpm publish --access public"));
+      console.log(chalk7.dim("  4. Use in other projects: pnpm add @workflow/scopes-" + packageName + "\n"));
+    }
+  } catch (error) {
+    spinner4.stop("\u2717 Failed to create package");
+    console.error(chalk7.red("\nError:"), error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/scope-migrate.ts
+import * as p5 from "@clack/prompts";
+import chalk8 from "chalk";
+import { existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
+async function scopeMigrateCommand(options) {
+  console.log(chalk8.bold.cyan("\n\u{1F504} Migrate Scopes to Custom Package\n"));
+  const cwd = process.cwd();
+  if (!hasConfig(cwd)) {
+    p5.cancel("No workflow.config.json found in current directory");
+    process.exit(1);
+  }
+  let config = null;
+  try {
+    config = await loadConfig(cwd);
+  } catch (error) {
+    console.error(chalk8.red("Failed to load config:"), error);
+    process.exit(1);
+  }
+  if (!config) {
+    p5.cancel("Failed to load configuration");
+    process.exit(1);
+  }
+  if (!config.scopes || config.scopes.length === 0) {
+    p5.cancel("No scopes found in workflow.config.json");
+    process.exit(1);
+  }
+  console.log(chalk8.dim(`Found ${config.scopes.length} scopes in workflow.config.json
+`));
+  console.log(chalk8.bold("Current scopes:"));
+  config.scopes.forEach((scope, i) => {
+    console.log(chalk8.dim(`  ${i + 1}. ${scope.emoji || "\u2022"} ${scope.name} - ${scope.description}`));
+  });
+  console.log();
+  const shouldContinue = await p5.confirm({
+    message: "Migrate these scopes to a custom package?",
+    initialValue: true
+  });
+  if (p5.isCancel(shouldContinue) || !shouldContinue) {
+    p5.cancel("Migration cancelled");
+    process.exit(0);
+  }
+  const isMonorepo = existsSync4(join4(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo) {
+    console.log(chalk8.dim("\n\u2713 Detected monorepo workspace\n"));
+  }
+  const packageNameInput = options.name || await p5.text({
+    message: "Package name for the scope preset:",
+    placeholder: config.projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+    validate: (value) => {
+      if (!value || value.length === 0) return "Package name is required";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Package name must be lowercase alphanumeric with hyphens";
+      if (value.length > 32) return "Package name must be 32 characters or less";
+      return void 0;
+    }
+  });
+  if (p5.isCancel(packageNameInput)) {
+    p5.cancel("Migration cancelled");
+    process.exit(0);
+  }
+  const packageName = packageNameInput;
+  const presetNameInput = await p5.text({
+    message: "Preset display name:",
+    placeholder: config.projectName,
+    defaultValue: config.projectName
+  });
+  if (p5.isCancel(presetNameInput)) {
+    p5.cancel("Migration cancelled");
+    process.exit(0);
+  }
+  const presetName = presetNameInput;
+  const validation = validateScopeDefinitions(config.scopes);
+  if (!validation.valid) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  Scope validation warnings:\n"));
+    validation.errors.forEach((error) => console.log(chalk8.yellow(`  \u2022 ${error}`)));
+    const shouldFix = await p5.confirm({
+      message: "Some scopes have validation issues. Continue anyway?",
+      initialValue: false
+    });
+    if (p5.isCancel(shouldFix) || !shouldFix) {
+      p5.cancel("Migration cancelled. Please fix validation errors first.");
+      process.exit(1);
+    }
+  }
+  let outputDir;
+  if (options.outputDir) {
+    outputDir = options.outputDir;
+  } else if (isMonorepo) {
+    outputDir = join4(cwd, "packages", `scopes-${packageName}`);
+  } else {
+    const customDir = await p5.text({
+      message: "Output directory:",
+      placeholder: `./scopes-${packageName}`,
+      defaultValue: `./scopes-${packageName}`
+    });
+    if (p5.isCancel(customDir)) {
+      p5.cancel("Migration cancelled");
+      process.exit(0);
+    }
+    outputDir = join4(cwd, customDir);
+  }
+  if (existsSync4(outputDir)) {
+    const shouldOverwrite = await p5.confirm({
+      message: `Directory ${outputDir} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p5.isCancel(shouldOverwrite) || !shouldOverwrite) {
+      p5.cancel("Migration cancelled");
+      process.exit(0);
+    }
+  }
+  const spinner4 = p5.spinner();
+  spinner4.start("Migrating scopes to package...");
+  try {
+    await mkdir3(join4(outputDir, "src"), { recursive: true });
+    const packageJson = {
+      name: `@workflow/scopes-${packageName}`,
+      version: "1.0.0",
+      description: `Migrated scope preset for ${presetName}`,
+      keywords: ["workflow", "scopes", packageName, "preset", "migrated"],
+      repository: {
+        type: "git",
+        url: "git+https://github.com/your-org/your-repo.git",
+        directory: `packages/scopes-${packageName}`
+      },
+      license: "MIT",
+      author: "Your Name",
+      type: "module",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        }
+      },
+      files: ["dist"],
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        typecheck: "tsc --noEmit",
+        test: "vitest run"
+      },
+      peerDependencies: {
+        "@hawkinside_out/workflow-agent": "^1.0.0"
+      },
+      devDependencies: {
+        "@hawkinside_out/workflow-agent": "^1.0.0",
+        tsup: "^8.0.1",
+        typescript: "^5.3.3",
+        vitest: "^1.0.0"
+      },
+      publishConfig: {
+        access: "public"
+      }
+    };
+    await writeFile3(
+      join4(outputDir, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+      "utf-8"
+    );
+    const tsconfig = {
+      extends: "../../tsconfig.json",
+      compilerOptions: {
+        outDir: "./dist",
+        rootDir: "./src"
+      },
+      include: ["src/**/*"]
+    };
+    await writeFile3(
+      join4(outputDir, "tsconfig.json"),
+      JSON.stringify(tsconfig, null, 2),
+      "utf-8"
+    );
+    const tsupConfig = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});
+`;
+    await writeFile3(join4(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    const indexTs = `import type { Scope } from '@hawkinside_out/workflow-agent/config';
+
+export const scopes: Scope[] = ${JSON.stringify(config.scopes, null, 2)};
+
+export const preset = {
+  name: '${presetName}',
+  description: 'Migrated scope configuration for ${presetName}',
+  scopes,
+  version: '1.0.0',
+};
+
+export default preset;
+`;
+    await writeFile3(join4(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    const testFile = `import { describe, it, expect } from 'vitest';
+import { scopes, preset } from './index.js';
+import { ScopeSchema } from '@hawkinside_out/workflow-agent/config';
+
+describe('${presetName} Scope Preset (Migrated)', () => {
+  it('should export valid scopes array', () => {
+    expect(scopes).toBeDefined();
+    expect(Array.isArray(scopes)).toBe(true);
+    expect(scopes.length).toBe(${config.scopes.length});
+  });
+
+  it('should have valid preset object', () => {
+    expect(preset).toBeDefined();
+    expect(preset.name).toBe('${presetName}');
+    expect(preset.scopes).toBe(scopes);
+    expect(preset.version).toBeDefined();
+  });
+
+  it('should have no duplicate scope names', () => {
+    const names = scopes.map(s => s.name);
+    const uniqueNames = new Set(names);
+    expect(uniqueNames.size).toBe(names.length);
+  });
+
+  it('should have all scopes match schema', () => {
+    scopes.forEach(scope => {
+      const result = ScopeSchema.safeParse(scope);
+      if (!result.success) {
+        console.error(\`Scope "\${scope.name}" failed validation:\`, result.error);
+      }
+      expect(result.success).toBe(true);
+    });
+  });
+
+  it('should have descriptions for all scopes', () => {
+    scopes.forEach(scope => {
+      expect(scope.description).toBeDefined();
+      expect(scope.description.length).toBeGreaterThan(0);
+    });
+  });
+});
+`;
+    await writeFile3(join4(outputDir, "src", "index.test.ts"), testFile, "utf-8");
+    spinner4.stop("\u2713 Package created from migrated scopes");
+    if (isMonorepo) {
+      const workspaceFile = join4(cwd, "pnpm-workspace.yaml");
+      const workspaceContent = await readFile2(workspaceFile, "utf-8");
+      const packagePath = `packages/scopes-${packageName}`;
+      if (!workspaceContent.includes(packagePath) && !workspaceContent.includes("packages/*")) {
+        console.log(chalk8.yellow("\n\u26A0\uFE0F  Add the following to pnpm-workspace.yaml:"));
+        console.log(chalk8.dim(`  - '${packagePath}'`));
+      } else {
+        console.log(chalk8.green("\n\u2713 Package will be included in workspace"));
+      }
+    }
+    const keepConfig = options.keepConfig ?? await p5.confirm({
+      message: "Remove migrated scopes from workflow.config.json?",
+      initialValue: false
+    });
+    if (!p5.isCancel(keepConfig) && !keepConfig) {
+      const configPath = join4(cwd, "workflow.config.json");
+      const updatedConfig = {
+        ...config,
+        scopes: [],
+        // Clear inline scopes
+        preset: `scopes-${packageName}`
+        // Reference the new package
+      };
+      await writeFile3(configPath, JSON.stringify(updatedConfig, null, 2), "utf-8");
+      console.log(chalk8.green("\u2713 Updated workflow.config.json"));
+      console.log(chalk8.dim("  \u2022 Cleared inline scopes"));
+      console.log(chalk8.dim(`  \u2022 Added preset reference: scopes-${packageName}
+`));
+    }
+    console.log(chalk8.green.bold("\n\u2728 Migration completed successfully!\n"));
+    console.log(chalk8.bold("Package details:"));
+    console.log(chalk8.dim(`  Location: ${outputDir}`));
+    console.log(chalk8.dim(`  Package: @workflow/scopes-${packageName}`));
+    console.log(chalk8.dim(`  Scopes: ${config.scopes.length} migrated
+`));
+    console.log(chalk8.bold("Next steps:\n"));
+    console.log(chalk8.dim(`  1. cd ${outputDir}`));
+    console.log(chalk8.dim(`  2. pnpm install`));
+    console.log(chalk8.dim(`  3. pnpm build`));
+    console.log(chalk8.dim(`  4. pnpm test`));
+    console.log(chalk8.dim(`  5. Update repository URL in package.json
+`));
+    if (!keepConfig) {
+      console.log(chalk8.bold("To use the migrated scopes:\n"));
+      console.log(chalk8.dim(`  1. Install the package: pnpm add -w @workflow/scopes-${packageName}`));
+      console.log(chalk8.dim(`  2. The preset is already referenced in workflow.config.json
+`));
+    }
+    console.log(chalk8.dim("\u{1F4A1} Tip: You can now reuse this scope package across multiple projects!\n"));
+  } catch (error) {
+    spinner4.stop("\u2717 Migration failed");
+    console.error(chalk8.red("\nError:"), error);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("workflow").description("A self-evolving workflow management system for AI agent development").version("1.0.0");
+program.command("init").description("Initialize workflow in current project").option("--migrate", "Auto-detect existing patterns and migrate").option("--workspace", "Initialize for multiple repositories").option("--preset <preset>", "Preset to use (saas, library, api, ecommerce, cms, custom)").option("--name <name>", "Project name").option("-y, --yes", "Skip confirmation prompts").action(initCommand);
+program.command("validate <type>").description("Validate branch name, commit message, or PR title").argument("<type>", "What to validate: branch, commit, or pr").argument("[value]", "Value to validate (defaults to current branch/HEAD commit)").option("--suggest-on-error", "Offer improvement suggestions on validation errors").action(validateCommand);
+program.command("config <action>").description("Manage workflow configuration").argument("<action>", "Action: get, set, add, remove").argument("[key]", "Config key").argument("[value]", "Config value").action(configCommand);
+program.command("suggest").description("Submit an improvement suggestion").argument("<feedback>", "Your improvement suggestion").option("--author <author>", "Your name or username").option("--category <category>", "Category: feature, bug, documentation, performance, other").action(suggestCommand);
+program.command("setup").description("Add workflow scripts to package.json").action(setupCommand);
+program.command("doctor").description("Run health check and get optimization suggestions").action(doctorCommand);
+program.command("scope:create").description("Create a custom scope package").option("--name <name>", 'Package name (e.g., "fintech", "gaming")').option("--scopes <scopes>", "Comma-separated scopes (format: name:description:emoji:category)").option("--preset-name <preset>", "Preset display name").option("--output-dir <dir>", "Output directory").option("--no-test", "Skip test file generation").action(scopeCreateCommand);
+program.command("scope:migrate").description("Migrate inline scopes to a custom package").option("--name <name>", "Package name for the preset").option("--output-dir <dir>", "Output directory").option("--keep-config", "Keep inline scopes in config after migration").action(scopeMigrateCommand);
+program.parse();
+//# sourceMappingURL=index.js.map