workflow-agent-cli 2.4.1 → 2.4.2

package/dist/cli/index.js

@@ -302,10 +302,10 @@ async function initCommand(options) {
     try {
       const presetModule = await import(`@workflow/scopes-${preset}`);
       scopes = presetModule.scopes || presetModule.default.scopes;
-      const spinner5 = p.spinner();
-      spinner5.start(`Loading ${presetModule.default?.name || preset} preset`);
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      spinner5.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
+      const spinner6 = p.spinner();
+      spinner6.start(`Loading ${presetModule.default?.name || preset} preset`);
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
+      spinner6.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
     } catch (error) {
       console.log(
         chalk.yellow(
@@ -352,8 +352,8 @@ async function initCommand(options) {
     process.exit(0);
   }
   if (shouldGenerateGuidelines) {
-    const spinner5 = p.spinner();
-    spinner5.start("Generating guidelines...");
+    const spinner6 = p.spinner();
+    spinner6.start("Generating guidelines...");
     try {
       const templatesDir = join(__dirname, "../../templates");
       await validateTemplateDirectory(templatesDir);
@@ -365,9 +365,9 @@ async function initCommand(options) {
         guidelinesDir,
         context
       );
-      spinner5.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
+      spinner6.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
     } catch (error) {
-      spinner5.stop("\u26A0\uFE0F  Could not generate guidelines");
+      spinner6.stop("\u26A0\uFE0F  Could not generate guidelines");
       console.log(
         chalk.yellow(
           `
@@ -837,8 +837,8 @@ async function scopeCreateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner5 = p4.spinner();
-  spinner5.start("Creating package structure...");
+  const spinner6 = p4.spinner();
+  spinner6.start("Creating package structure...");
   try {
     await mkdir2(join3(outputDir, "src"), { recursive: true });
     const packageJson = {
@@ -969,7 +969,7 @@ describe('${presetName} Scope Preset', () => {
         "utf-8"
       );
     }
-    spinner5.stop("\u2713 Package structure created");
+    spinner6.stop("\u2713 Package structure created");
     if (isMonorepo) {
       const workspaceFile = join3(cwd, "pnpm-workspace.yaml");
       const workspaceContent = await readFile(workspaceFile, "utf-8");
@@ -1021,7 +1021,7 @@ describe('${presetName} Scope Preset', () => {
       );
     }
   } catch (error) {
-    spinner5.stop("\u2717 Failed to create package");
+    spinner6.stop("\u2717 Failed to create package");
     console.error(chalk7.red("\nError:"), error);
     process.exit(1);
   }
@@ -1149,8 +1149,8 @@ async function scopeMigrateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner5 = p5.spinner();
-  spinner5.start("Migrating scopes to package...");
+  const spinner6 = p5.spinner();
+  spinner6.start("Migrating scopes to package...");
   try {
     await mkdir3(join4(outputDir, "src"), { recursive: true });
     const packageJson = {
@@ -1278,7 +1278,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
 });
 `;
     await writeFile3(join4(outputDir, "src", "index.test.ts"), testFile, "utf-8");
-    spinner5.stop("\u2713 Package created from migrated scopes");
+    spinner6.stop("\u2713 Package created from migrated scopes");
     if (isMonorepo) {
       const workspaceFile = join4(cwd, "pnpm-workspace.yaml");
       const workspaceContent = await readFile2(workspaceFile, "utf-8");
@@ -1350,7 +1350,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
       )
     );
   } catch (error) {
-    spinner5.stop("\u2717 Migration failed");
+    spinner6.stop("\u2717 Migration failed");
     console.error(chalk8.red("\nError:"), error);
     process.exit(1);
   }
@@ -1464,8 +1464,8 @@ async function recordSuccessfulFixes(cwd, result) {
     let frameworkVersion = "0.0.0";
     try {
       const fs2 = await import("fs");
-      const path2 = await import("path");
-      const packageJsonPath = path2.join(cwd, "package.json");
+      const path3 = await import("path");
+      const packageJsonPath = path3.join(cwd, "package.json");
       const packageJson = JSON.parse(
         await fs2.promises.readFile(packageJsonPath, "utf-8")
       );
@@ -1584,14 +1584,14 @@ import chalk10 from "chalk";
 async function autoSetupCommand(options) {
   console.log(chalk10.bold.cyan("\n\u{1F527} Workflow Agent Auto-Setup\n"));
   const cwd = process.cwd();
-  const spinner5 = p6.spinner();
-  spinner5.start("Analyzing project...");
+  const spinner6 = p6.spinner();
+  spinner6.start("Analyzing project...");
   let report;
   try {
     report = await generateAuditReport(cwd);
-    spinner5.stop("\u2713 Project analysis complete");
+    spinner6.stop("\u2713 Project analysis complete");
   } catch (error) {
-    spinner5.stop("\u2717 Failed to analyze project");
+    spinner6.stop("\u2717 Failed to analyze project");
     console.error(
       chalk10.red(
         `Error: ${error instanceof Error ? error.message : String(error)}`
@@ -2314,6 +2314,435 @@ async function learnStatsCommand() {
   console.log("");
 }
 
+// src/cli/commands/solution.ts
+import chalk12 from "chalk";
+import * as p8 from "@clack/prompts";
+import * as path2 from "path";
+import {
+  PatternStore as PatternStore3,
+  CodeAnalyzer
+} from "@hawkinside_out/workflow-improvement-tracker";
+function getWorkspacePath2() {
+  return process.cwd();
+}
+function formatDate2(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatCategory(category) {
+  const icons = {
+    auth: "\u{1F510}",
+    api: "\u{1F310}",
+    database: "\u{1F4BE}",
+    ui: "\u{1F3A8}",
+    testing: "\u{1F9EA}",
+    deployment: "\u{1F680}",
+    integrations: "\u{1F517}",
+    performance: "\u26A1",
+    security: "\u{1F6E1}\uFE0F",
+    other: "\u{1F4E6}",
+    state: "\u{1F504}",
+    forms: "\u{1F4DD}",
+    "error-handling": "\u26A0\uFE0F",
+    caching: "\u{1F4A8}"
+  };
+  return `${icons[category]} ${category}`;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+async function solutionCaptureCommand(options) {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u{1F4E6} Capture Solution Pattern\n"));
+  let targetPath = options.path;
+  if (!targetPath) {
+    const pathInput = await p8.text({
+      message: "Path to the solution directory:",
+      placeholder: "./src/auth",
+      validate: (val) => {
+        if (!val) return "Path is required";
+        return void 0;
+      }
+    });
+    if (p8.isCancel(pathInput)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    targetPath = pathInput;
+  }
+  const absolutePath = path2.isAbsolute(targetPath) ? targetPath : path2.resolve(cwd, targetPath);
+  let name = options.name;
+  if (!name) {
+    const nameInput = await p8.text({
+      message: "Solution name:",
+      placeholder: "JWT Authentication",
+      validate: (val) => {
+        if (!val || val.length < 3) return "Name must be at least 3 characters";
+        return void 0;
+      }
+    });
+    if (p8.isCancel(nameInput)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    name = nameInput;
+  }
+  let description = options.description;
+  if (!description) {
+    const descInput = await p8.text({
+      message: "Solution description:",
+      placeholder: "Complete JWT-based authentication with refresh tokens",
+      validate: (val) => {
+        if (!val || val.length < 10)
+          return "Description must be at least 10 characters";
+        return void 0;
+      }
+    });
+    if (p8.isCancel(descInput)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    description = descInput;
+  }
+  let category = options.category;
+  if (!category) {
+    const categoryChoice = await p8.select({
+      message: "Solution category:",
+      options: [
+        { value: "auth", label: "\u{1F510} Authentication" },
+        { value: "api", label: "\u{1F310} API" },
+        { value: "database", label: "\u{1F4BE} Database" },
+        { value: "ui", label: "\u{1F3A8} UI/Components" },
+        { value: "testing", label: "\u{1F9EA} Testing" },
+        { value: "deployment", label: "\u{1F680} Deployment" },
+        { value: "integrations", label: "\u{1F517} Integrations" },
+        { value: "performance", label: "\u26A1 Performance" },
+        { value: "security", label: "\u{1F6E1}\uFE0F Security" },
+        { value: "state", label: "\u{1F504} State Management" },
+        { value: "forms", label: "\u{1F4DD} Forms" },
+        { value: "error-handling", label: "\u26A0\uFE0F Error Handling" },
+        { value: "caching", label: "\u{1F4A8} Caching" },
+        { value: "other", label: "\u{1F4E6} Other" }
+      ]
+    });
+    if (p8.isCancel(categoryChoice)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    category = categoryChoice;
+  }
+  let keywords = [];
+  if (options.keywords) {
+    keywords = options.keywords.split(",").map((k) => k.trim());
+  } else {
+    const keywordsInput = await p8.text({
+      message: "Keywords (comma-separated):",
+      placeholder: "jwt, authentication, login, refresh-token"
+    });
+    if (p8.isCancel(keywordsInput)) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (keywordsInput) {
+      keywords = keywordsInput.split(",").map((k) => k.trim());
+    }
+  }
+  const spinner6 = p8.spinner();
+  spinner6.start("Analyzing solution...");
+  const analyzer = new CodeAnalyzer({
+    anonymize: options.anonymize ?? false
+  });
+  try {
+    const pattern = await analyzer.createSolutionPattern(
+      absolutePath,
+      name,
+      description,
+      category,
+      keywords
+    );
+    spinner6.stop("Solution analyzed");
+    console.log(chalk12.green("\n\u2713 Solution captured successfully!\n"));
+    console.log(chalk12.dim("\u2500".repeat(50)));
+    console.log(`${chalk12.bold("Name:")} ${pattern.name}`);
+    console.log(`${chalk12.bold("Category:")} ${formatCategory(pattern.category)}`);
+    console.log(`${chalk12.bold("Files:")} ${pattern.implementation.files.length}`);
+    console.log(
+      `${chalk12.bold("Dependencies:")} ${pattern.implementation.dependencies.length}`
+    );
+    console.log(
+      `${chalk12.bold("Framework:")} ${pattern.compatibility.framework || "generic"}`
+    );
+    console.log(chalk12.dim("\u2500".repeat(50)));
+    const confirm8 = await p8.confirm({
+      message: "Save this solution pattern?",
+      initialValue: true
+    });
+    if (p8.isCancel(confirm8) || !confirm8) {
+      p8.cancel("Solution not saved");
+      process.exit(0);
+    }
+    await store.saveSolution(pattern);
+    console.log(chalk12.green(`
+\u2713 Solution saved with ID: ${pattern.id}
+`));
+  } catch (error) {
+    spinner6.stop("Analysis failed");
+    console.error(chalk12.red(`
+\u2717 Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+async function solutionSearchCommand(query, options) {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u{1F50D} Search Solution Patterns\n"));
+  const keywords = query.split(/\s+/).filter((k) => k.length > 0);
+  const result = await store.searchSolutions(keywords, {
+    category: options.category,
+    framework: options.framework,
+    limit: options.limit ?? 10
+  });
+  if (!result.success || !result.data) {
+    console.error(chalk12.red(`
+\u2717 Search failed: ${result.error}
+`));
+    return;
+  }
+  const solutions = result.data;
+  if (solutions.length === 0) {
+    console.log(chalk12.yellow("No solutions found matching your query.\n"));
+    console.log(chalk12.dim("Try different keywords or fewer filters."));
+    return;
+  }
+  console.log(chalk12.green(`Found ${solutions.length} solution(s):
+`));
+  console.log(chalk12.dim("\u2500".repeat(70)));
+  for (const solution of solutions) {
+    console.log(
+      `${chalk12.bold(solution.name)} ${chalk12.dim(`(${solution.id.slice(0, 8)})`)}`
+    );
+    console.log(`  ${formatCategory(solution.category)}`);
+    console.log(`  ${chalk12.dim(truncate(solution.description, 60))}`);
+    console.log(
+      `  Files: ${solution.implementation.files.length} | Framework: ${solution.compatibility.framework || "generic"} | Uses: ${solution.metrics.applications}`
+    );
+    console.log(chalk12.dim("\u2500".repeat(70)));
+  }
+  console.log(chalk12.dim("\nUse 'workflow solution:apply <id>' to apply a solution."));
+}
+async function solutionListCommand(options) {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u{1F4CB} Solution Patterns\n"));
+  const result = await store.listSolutions({
+    category: options.category,
+    framework: options.framework,
+    includeDeprecated: options.deprecated ?? false,
+    limit: options.limit ?? 20
+  });
+  if (!result.success || !result.data) {
+    console.error(chalk12.red(`
+\u2717 List failed: ${result.error}
+`));
+    return;
+  }
+  const solutions = result.data;
+  if (solutions.length === 0) {
+    console.log(chalk12.yellow("No solutions found.\n"));
+    console.log(chalk12.dim("Use 'workflow solution:capture' to capture a solution."));
+    return;
+  }
+  console.log(chalk12.green(`${solutions.length} solution(s):
+`));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const solution of solutions) {
+    const list = byCategory.get(solution.category) || [];
+    list.push(solution);
+    byCategory.set(solution.category, list);
+  }
+  for (const [category, items] of byCategory) {
+    console.log(chalk12.bold(`
+${formatCategory(category)}`));
+    console.log(chalk12.dim("\u2500".repeat(50)));
+    for (const solution of items) {
+      const deprecated = solution.deprecatedAt ? chalk12.red(" [DEPRECATED]") : "";
+      console.log(
+        `  ${chalk12.cyan(solution.id.slice(0, 8))} ${solution.name}${deprecated}`
+      );
+      console.log(`    ${chalk12.dim(truncate(solution.description, 50))}`);
+      console.log(
+        chalk12.dim(
+          `    Created: ${formatDate2(solution.createdAt)} | Files: ${solution.implementation.files.length}`
+        )
+      );
+    }
+  }
+  console.log(
+    chalk12.dim("\nUse 'workflow solution:search <query>' to find specific solutions.")
+  );
+}
+async function solutionApplyCommand(solutionId, options) {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u{1F680} Apply Solution Pattern\n"));
+  const result = await store.getSolution(solutionId);
+  if (!result.success || !result.data) {
+    console.error(chalk12.red(`
+\u2717 Solution not found: ${solutionId}
+`));
+    process.exit(1);
+  }
+  const solution = result.data;
+  if (solution.deprecatedAt) {
+    console.log(
+      chalk12.yellow(
+        `\u26A0\uFE0F  This solution is deprecated: ${solution.deprecationReason || "No reason provided"}
+`
+      )
+    );
+    const proceed = await p8.confirm({
+      message: "Do you want to continue?",
+      initialValue: false
+    });
+    if (p8.isCancel(proceed) || !proceed) {
+      p8.cancel("Operation cancelled");
+      process.exit(0);
+    }
+  }
+  console.log(chalk12.bold(`Solution: ${solution.name}`));
+  console.log(chalk12.dim(solution.description));
+  console.log();
+  console.log(chalk12.bold("Files to create:"));
+  const filesToApply = options.includeTests ? solution.implementation.files : solution.implementation.files.filter((f) => f.role !== "test");
+  for (const file of filesToApply) {
+    console.log(chalk12.dim(`  \u2022 ${file.path} (${file.role})`));
+  }
+  console.log();
+  if (solution.implementation.dependencies.length > 0) {
+    console.log(chalk12.bold("Dependencies to install:"));
+    for (const dep of solution.implementation.dependencies) {
+      console.log(chalk12.dim(`  \u2022 ${dep.name}@${dep.version}`));
+    }
+    console.log();
+  }
+  if (solution.implementation.envVars.length > 0) {
+    console.log(chalk12.bold("Environment variables needed:"));
+    for (const env of solution.implementation.envVars) {
+      const required = env.required ? chalk12.red("*") : "";
+      console.log(chalk12.dim(`  \u2022 ${env.name}${required}`));
+    }
+    console.log();
+  }
+  if (options.dryRun) {
+    console.log(chalk12.yellow("Dry run mode - no files were created.\n"));
+    return;
+  }
+  const confirm8 = await p8.confirm({
+    message: "Apply this solution?",
+    initialValue: true
+  });
+  if (p8.isCancel(confirm8) || !confirm8) {
+    p8.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner6 = p8.spinner();
+  spinner6.start("Applying solution...");
+  try {
+    const outputDir = options.output || cwd;
+    const fs2 = await import("fs");
+    const pathModule = await import("path");
+    for (const file of filesToApply) {
+      const filePath = pathModule.join(outputDir, file.path);
+      const dir = pathModule.dirname(filePath);
+      await fs2.promises.mkdir(dir, { recursive: true });
+      await fs2.promises.writeFile(filePath, file.content);
+    }
+    await store.updateSolutionMetrics(solution.id, true);
+    spinner6.stop("Solution applied");
+    console.log(chalk12.green(`
+\u2713 Solution applied successfully!
+`));
+    console.log(chalk12.dim(`Created ${filesToApply.length} file(s).`));
+    if (solution.implementation.dependencies.length > 0) {
+      console.log(
+        chalk12.cyan("\nNext step: Install dependencies with:")
+      );
+      const deps = solution.implementation.dependencies.map((d) => `${d.name}@${d.version}`).join(" ");
+      console.log(chalk12.dim(`  npm install ${deps}`));
+    }
+  } catch (error) {
+    spinner6.stop("Application failed");
+    await store.updateSolutionMetrics(solution.id, false);
+    console.error(chalk12.red(`
+\u2717 Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+async function solutionDeprecateCommand(solutionId, reason) {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u26A0\uFE0F  Deprecate Solution Pattern\n"));
+  const result = await store.getSolution(solutionId);
+  if (!result.success || !result.data) {
+    console.error(chalk12.red(`
+\u2717 Solution not found: ${solutionId}
+`));
+    process.exit(1);
+  }
+  const solution = result.data;
+  console.log(`Solution: ${chalk12.bold(solution.name)}`);
+  console.log(`Reason: ${reason}
+`);
+  const confirm8 = await p8.confirm({
+    message: "Deprecate this solution?",
+    initialValue: false
+  });
+  if (p8.isCancel(confirm8) || !confirm8) {
+    p8.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  await store.deprecateSolution(solutionId, reason);
+  console.log(chalk12.green(`
+\u2713 Solution deprecated.
+`));
+}
+async function solutionStatsCommand() {
+  const cwd = getWorkspacePath2();
+  const store = new PatternStore3(cwd);
+  console.log(chalk12.cyan("\n\u{1F4CA} Solution Pattern Statistics\n"));
+  const stats = await store.getStats();
+  console.log(chalk12.dim("\u2500".repeat(40)));
+  console.log(`${chalk12.bold("Solutions:")} ${stats.totalSolutions}`);
+  console.log(`  Active: ${stats.totalSolutions - stats.deprecatedSolutions}`);
+  console.log(`  Deprecated: ${stats.deprecatedSolutions}`);
+  console.log(`  Private: ${stats.privateSolutions}`);
+  console.log(`  Synced: ${stats.syncedSolutions}`);
+  console.log(chalk12.dim("\u2500".repeat(40)));
+  console.log(`${chalk12.bold("Fixes:")} ${stats.totalFixes}`);
+  console.log(`${chalk12.bold("Blueprints:")} ${stats.totalBlueprints}`);
+  console.log(chalk12.dim("\u2500".repeat(40)));
+  console.log(`
+${chalk12.bold("By Category:")}`);
+  const listResult = await store.listSolutions({ limit: 1e3 });
+  if (listResult.success && listResult.data) {
+    const categories = /* @__PURE__ */ new Map();
+    for (const s of listResult.data) {
+      categories.set(s.category, (categories.get(s.category) || 0) + 1);
+    }
+    for (const [category, count] of categories) {
+      console.log(`  ${formatCategory(category)}: ${count}`);
+    }
+  }
+  console.log();
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("workflow").description(
@@ -2351,5 +2780,11 @@ program.command("learn:sync").description("Sync patterns with remote registry").
 program.command("learn:config").description("Configure learning settings").option("--enable-sync", "Enable pattern sync").option("--disable-sync", "Disable pattern sync").option("--enable-telemetry", "Enable anonymous telemetry").option("--disable-telemetry", "Disable telemetry").option("--reset-id", "Reset contributor ID").option("--show", "Show current configuration").action(learnConfigCommand);
 program.command("learn:deprecate <patternId> <reason>").description("Deprecate an outdated pattern").argument("<patternId>", "Pattern ID to deprecate").argument("<reason>", "Reason for deprecation").action(learnDeprecateCommand);
 program.command("learn:stats").description("Show learning statistics").action(learnStatsCommand);
+program.command("solution:capture").description("Capture a solution pattern from working code").option("--name <name>", "Solution name").option("--description <desc>", "Solution description").option("--category <cat>", "Category (auth, api, database, ui, testing, deployment, integration, performance, security, other)").option("--keywords <kw>", "Comma-separated keywords").option("--path <path>", "Path to the solution directory").option("--anonymize", "Anonymize sensitive data in code").action(solutionCaptureCommand);
+program.command("solution:search <query>").description("Search for solution patterns").argument("<query>", "Search query (keywords, problem description)").option("--category <cat>", "Filter by category").option("--framework <fw>", "Filter by framework").option("--limit <n>", "Maximum results", "10").action(solutionSearchCommand);
+program.command("solution:list").description("List all solution patterns").option("--category <cat>", "Filter by category").option("--framework <fw>", "Filter by framework").option("--deprecated", "Include deprecated solutions").option("--limit <n>", "Maximum results", "20").action(solutionListCommand);
+program.command("solution:apply <solutionId>").description("Apply a solution pattern to the current project").argument("<solutionId>", "Solution ID to apply").option("--output <dir>", "Output directory").option("--dry-run", "Preview without applying").option("--include-tests", "Include test files").action(solutionApplyCommand);
+program.command("solution:deprecate <solutionId> <reason>").description("Deprecate a solution pattern").argument("<solutionId>", "Solution ID to deprecate").argument("<reason>", "Reason for deprecation").action(solutionDeprecateCommand);
+program.command("solution:stats").description("Show solution pattern statistics").action(solutionStatsCommand);
 program.parse();
 //# sourceMappingURL=index.js.map