workflow-agent-cli 2.17.0 → 2.18.1

package/dist/cli/index.js

@@ -324,7 +324,7 @@ async function initCommand(options) {
       scopes = presetModule.scopes || presetModule.default.scopes;
       const spinner10 = p.spinner();
       spinner10.start(`Loading ${presetModule.default?.name || preset} preset`);
-      await new Promise((resolve2) => setTimeout(resolve2, 500));
+      await new Promise((resolve3) => setTimeout(resolve3, 500));
       spinner10.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
     } catch (error) {
       console.log(
@@ -5235,8 +5235,7 @@ import {
   TelemetryCollector as TelemetryCollector2,
   FixPatternSchema,
   BlueprintSchema,
-  SolutionPatternSchema,
-  createDefaultMetrics
+  SolutionPatternSchema
 } from "@hawkinside_out/workflow-improvement-tracker";
 
 // src/sync/registry-client.ts
@@ -5380,7 +5379,7 @@ var RegistryClient = class {
         }
         if (attempt < this.retries) {
           await new Promise(
-            (resolve2) => setTimeout(resolve2, Math.pow(2, attempt) * 1e3)
+            (resolve3) => setTimeout(resolve3, Math.pow(2, attempt) * 1e3)
           );
         }
       }
@@ -5834,8 +5833,8 @@ async function learnApplyCommand(patternId, options) {
       chalk16.yellow("\n\u{1F4CB} DRY-RUN MODE: No changes will be applied\n")
     );
   }
-  const framework = options.framework ?? patternData.compatibility.frameworks[0]?.name ?? "unknown";
-  const version = options.version ?? patternData.compatibility.frameworks[0]?.version ?? "0.0.0";
+  const framework = options.framework ?? patternData.compatibility?.frameworks?.[0]?.name ?? "unknown";
+  const version = options.version ?? patternData.compatibility?.frameworks?.[0]?.version ?? "0.0.0";
   await telemetry.recordApplication(patternId, patternType, framework, version);
   if (patternType === "fix") {
     const fixPattern = patternData;
@@ -6723,6 +6722,457 @@ function tryAutoFix(data, type, issues) {
   }
   return { fixable: false };
 }
+var LIBRARY_TAG_MAP = {
+  // Frontend Frameworks
+  "react": [{ category: "framework", name: "react" }],
+  "react-dom": [{ category: "framework", name: "react" }],
+  "next": [{ category: "framework", name: "next" }],
+  "vue": [{ category: "framework", name: "vue" }],
+  "nuxt": [{ category: "framework", name: "nuxt" }],
+  "svelte": [{ category: "framework", name: "svelte" }],
+  "@sveltejs/kit": [{ category: "framework", name: "sveltekit" }],
+  "solid-js": [{ category: "framework", name: "solid" }],
+  "@angular/core": [{ category: "framework", name: "angular" }],
+  "astro": [{ category: "framework", name: "astro" }],
+  "remix": [{ category: "framework", name: "remix" }],
+  // Backend Frameworks
+  "express": [{ category: "framework", name: "express" }],
+  "fastify": [{ category: "framework", name: "fastify" }],
+  "hono": [{ category: "framework", name: "hono" }],
+  "koa": [{ category: "framework", name: "koa" }],
+  "@nestjs/core": [{ category: "framework", name: "nestjs" }],
+  "hapi": [{ category: "framework", name: "hapi" }],
+  // Testing
+  "vitest": [{ category: "tooling", name: "vitest" }, { category: "category", name: "testing" }],
+  "jest": [{ category: "tooling", name: "jest" }, { category: "category", name: "testing" }],
+  "@testing-library/react": [{ category: "tooling", name: "testing-library" }],
+  "playwright": [{ category: "tooling", name: "playwright" }, { category: "category", name: "e2e" }],
+  "cypress": [{ category: "tooling", name: "cypress" }, { category: "category", name: "e2e" }],
+  // State Management
+  "zustand": [{ category: "tooling", name: "zustand" }, { category: "category", name: "state" }],
+  "redux": [{ category: "tooling", name: "redux" }, { category: "category", name: "state" }],
+  "@reduxjs/toolkit": [{ category: "tooling", name: "redux-toolkit" }, { category: "category", name: "state" }],
+  "jotai": [{ category: "tooling", name: "jotai" }, { category: "category", name: "state" }],
+  "recoil": [{ category: "tooling", name: "recoil" }, { category: "category", name: "state" }],
+  "mobx": [{ category: "tooling", name: "mobx" }, { category: "category", name: "state" }],
+  "pinia": [{ category: "tooling", name: "pinia" }, { category: "category", name: "state" }],
+  "xstate": [{ category: "tooling", name: "xstate" }, { category: "category", name: "state-machine" }],
+  // Database & ORM
+  "prisma": [{ category: "tooling", name: "prisma" }, { category: "category", name: "database" }],
+  "@prisma/client": [{ category: "tooling", name: "prisma" }, { category: "category", name: "database" }],
+  "drizzle-orm": [{ category: "tooling", name: "drizzle" }, { category: "category", name: "database" }],
+  "typeorm": [{ category: "tooling", name: "typeorm" }, { category: "category", name: "database" }],
+  "mongoose": [{ category: "tooling", name: "mongoose" }, { category: "category", name: "mongodb" }],
+  "knex": [{ category: "tooling", name: "knex" }, { category: "category", name: "database" }],
+  "sequelize": [{ category: "tooling", name: "sequelize" }, { category: "category", name: "database" }],
+  // Authentication
+  "next-auth": [{ category: "tooling", name: "next-auth" }, { category: "category", name: "auth" }],
+  "@auth/core": [{ category: "tooling", name: "authjs" }, { category: "category", name: "auth" }],
+  "passport": [{ category: "tooling", name: "passport" }, { category: "category", name: "auth" }],
+  "lucia": [{ category: "tooling", name: "lucia" }, { category: "category", name: "auth" }],
+  "@clerk/nextjs": [{ category: "tooling", name: "clerk" }, { category: "category", name: "auth" }],
+  // UI Libraries
+  "@radix-ui/react-dialog": [{ category: "tooling", name: "radix-ui" }],
+  "@radix-ui/react-dropdown-menu": [{ category: "tooling", name: "radix-ui" }],
+  "@shadcn/ui": [{ category: "tooling", name: "shadcn" }],
+  "@chakra-ui/react": [{ category: "tooling", name: "chakra-ui" }],
+  "@mantine/core": [{ category: "tooling", name: "mantine" }],
+  "@headlessui/react": [{ category: "tooling", name: "headlessui" }],
+  "antd": [{ category: "tooling", name: "antd" }],
+  "@mui/material": [{ category: "tooling", name: "material-ui" }],
+  // Styling
+  "tailwindcss": [{ category: "tooling", name: "tailwind" }],
+  "styled-components": [{ category: "tooling", name: "styled-components" }],
+  "@emotion/react": [{ category: "tooling", name: "emotion" }],
+  "sass": [{ category: "tooling", name: "sass" }],
+  // API & Data Fetching
+  "@tanstack/react-query": [{ category: "tooling", name: "tanstack-query" }, { category: "category", name: "data-fetching" }],
+  "swr": [{ category: "tooling", name: "swr" }, { category: "category", name: "data-fetching" }],
+  "@trpc/server": [{ category: "tooling", name: "trpc" }, { category: "category", name: "api" }],
+  "@trpc/client": [{ category: "tooling", name: "trpc" }, { category: "category", name: "api" }],
+  "graphql": [{ category: "tooling", name: "graphql" }, { category: "category", name: "api" }],
+  "@apollo/client": [{ category: "tooling", name: "apollo" }, { category: "category", name: "graphql" }],
+  "axios": [{ category: "tooling", name: "axios" }],
+  // Form Libraries
+  "react-hook-form": [{ category: "tooling", name: "react-hook-form" }, { category: "category", name: "forms" }],
+  "formik": [{ category: "tooling", name: "formik" }, { category: "category", name: "forms" }],
+  "@tanstack/react-form": [{ category: "tooling", name: "tanstack-form" }, { category: "category", name: "forms" }],
+  // Validation
+  "zod": [{ category: "tooling", name: "zod" }, { category: "category", name: "validation" }],
+  "yup": [{ category: "tooling", name: "yup" }, { category: "category", name: "validation" }],
+  "valibot": [{ category: "tooling", name: "valibot" }, { category: "category", name: "validation" }],
+  // Build Tools
+  "vite": [{ category: "tooling", name: "vite" }],
+  "esbuild": [{ category: "tooling", name: "esbuild" }],
+  "tsup": [{ category: "tooling", name: "tsup" }],
+  "webpack": [{ category: "tooling", name: "webpack" }],
+  "turbo": [{ category: "tooling", name: "turborepo" }],
+  // Utilities
+  "lodash": [{ category: "tooling", name: "lodash" }],
+  "date-fns": [{ category: "tooling", name: "date-fns" }],
+  "dayjs": [{ category: "tooling", name: "dayjs" }],
+  "uuid": [{ category: "tooling", name: "uuid" }],
+  "nanoid": [{ category: "tooling", name: "nanoid" }],
+  // CLI & Developer Tools
+  "commander": [{ category: "tooling", name: "commander" }, { category: "category", name: "cli" }],
+  "yargs": [{ category: "tooling", name: "yargs" }, { category: "category", name: "cli" }],
+  "@clack/prompts": [{ category: "tooling", name: "clack" }, { category: "category", name: "cli" }],
+  "inquirer": [{ category: "tooling", name: "inquirer" }, { category: "category", name: "cli" }],
+  "chalk": [{ category: "tooling", name: "chalk" }],
+  // Runtime & Languages
+  "typescript": [{ category: "language", name: "typescript" }]
+};
+function inferPatternName(filePaths) {
+  if (filePaths.length === 1) {
+    const fileName = path2.basename(filePaths[0]);
+    const nameWithoutExt = fileName.replace(/\.[^.]+$/, "");
+    return nameWithoutExt.replace(/[-_]/g, " ").replace(/([A-Z])/g, " $1").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+  }
+  const dirs = filePaths.map((p13) => path2.dirname(p13));
+  const uniqueDirs = [...new Set(dirs)];
+  if (uniqueDirs.length === 1 && uniqueDirs[0] !== ".") {
+    const dirName = path2.basename(uniqueDirs[0]);
+    return dirName.replace(/[-_]/g, " ").replace(/([A-Z])/g, " $1").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ") + " Pattern";
+  }
+  const fileNames = filePaths.map((p13) => path2.basename(p13).replace(/\.[^.]+$/, ""));
+  if (fileNames.length > 0) {
+    let commonPrefix = fileNames[0];
+    for (const name of fileNames.slice(1)) {
+      while (!name.startsWith(commonPrefix) && commonPrefix.length > 0) {
+        commonPrefix = commonPrefix.slice(0, -1);
+      }
+    }
+    if (commonPrefix.length > 2) {
+      return commonPrefix.replace(/[-_]/g, " ").replace(/([A-Z])/g, " $1").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ") + " Pattern";
+    }
+  }
+  return `Multi-file Pattern (${filePaths.length} files)`;
+}
+async function inferTagsFromDependencies(cwd) {
+  const tags = [];
+  const seenTags = /* @__PURE__ */ new Set();
+  const packageJsonPath = path2.join(cwd, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return tags;
+  }
+  try {
+    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    for (const dep of Object.keys(allDeps)) {
+      const mappedTags = LIBRARY_TAG_MAP[dep];
+      if (mappedTags) {
+        for (const tag of mappedTags) {
+          const key = `${tag.category}:${tag.name}`;
+          if (!seenTags.has(key)) {
+            seenTags.add(key);
+            tags.push(tag);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return tags;
+}
+function inferTagsFromContent(filePaths) {
+  const tags = [];
+  const seenTags = /* @__PURE__ */ new Set();
+  const addTag = (category, name) => {
+    const key = `${category}:${name}`;
+    if (!seenTags.has(key)) {
+      seenTags.add(key);
+      tags.push({ category, name });
+    }
+  };
+  for (const filePath of filePaths) {
+    const ext = path2.extname(filePath).toLowerCase();
+    const fileName = path2.basename(filePath).toLowerCase();
+    if (ext === ".ts" || ext === ".tsx") {
+      addTag("language", "typescript");
+    } else if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") {
+      addTag("language", "javascript");
+    } else if (ext === ".py") {
+      addTag("language", "python");
+    } else if (ext === ".go") {
+      addTag("language", "go");
+    } else if (ext === ".rs") {
+      addTag("language", "rust");
+    } else if (ext === ".css" || ext === ".scss" || ext === ".sass") {
+      addTag("tooling", "css");
+    }
+    if (ext === ".tsx" || ext === ".jsx") {
+      addTag("framework", "react");
+    }
+    if (fileName.includes(".test.") || fileName.includes(".spec.") || fileName.startsWith("test_")) {
+      addTag("category", "testing");
+    }
+    if (fileName.includes("config") || fileName.startsWith(".")) {
+      addTag("category", "configuration");
+    }
+    if (filePath.includes("/components/") || filePath.includes("\\components\\")) {
+      addTag("category", "component");
+    }
+    if (filePath.includes("/hooks/") || filePath.includes("\\hooks\\") || fileName.startsWith("use")) {
+      addTag("category", "hooks");
+    }
+    if (filePath.includes("/api/") || filePath.includes("\\api\\") || filePath.includes("/routes/")) {
+      addTag("category", "api");
+    }
+    if (filePath.includes("/utils/") || filePath.includes("\\utils\\") || filePath.includes("/lib/")) {
+      addTag("category", "utilities");
+    }
+  }
+  return tags;
+}
+async function learnCaptureCommand(paths, options) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  console.log(chalk16.cyan("\n\u{1F4F8} Capture Files as Blueprint\n"));
+  const resolvedPaths = [];
+  const relativePaths = [];
+  for (const inputPath of paths) {
+    const absolutePath = path2.isAbsolute(inputPath) ? inputPath : path2.resolve(cwd, inputPath);
+    if (!fs2.existsSync(absolutePath)) {
+      console.log(chalk16.red(`\u2717 File not found: ${inputPath}`));
+      process.exit(1);
+    }
+    const stat = fs2.statSync(absolutePath);
+    if (stat.isDirectory()) {
+      const files2 = getAllFilesInDir(absolutePath);
+      for (const file of files2) {
+        resolvedPaths.push(file);
+        relativePaths.push(path2.relative(cwd, file));
+      }
+    } else {
+      resolvedPaths.push(absolutePath);
+      relativePaths.push(path2.relative(cwd, absolutePath));
+    }
+  }
+  if (resolvedPaths.length === 0) {
+    console.log(chalk16.red("\u2717 No files found to capture"));
+    process.exit(1);
+  }
+  console.log(chalk16.dim(`Found ${resolvedPaths.length} file(s) to capture:
+`));
+  for (const relPath of relativePaths.slice(0, 10)) {
+    console.log(chalk16.dim(`  \u2022 ${relPath}`));
+  }
+  if (relativePaths.length > 10) {
+    console.log(chalk16.dim(`  ... and ${relativePaths.length - 10} more`));
+  }
+  console.log();
+  const depTags = await inferTagsFromDependencies(cwd);
+  const contentTags = inferTagsFromContent(relativePaths);
+  const allInferredTags = [...depTags, ...contentTags];
+  const seenTagKeys = /* @__PURE__ */ new Set();
+  const uniqueTags = [];
+  for (const tag of allInferredTags) {
+    const key = `${tag.category}:${tag.name}`;
+    if (!seenTagKeys.has(key)) {
+      seenTagKeys.add(key);
+      uniqueTags.push(tag);
+    }
+  }
+  if (options.tags) {
+    const tagPairs = options.tags.split(",").map((t) => t.trim());
+    for (const pair of tagPairs) {
+      const [cat, val] = pair.split(":");
+      if (cat && val) {
+        const key = `${cat}:${val}`;
+        if (!seenTagKeys.has(key)) {
+          seenTagKeys.add(key);
+          uniqueTags.push({
+            category: cat,
+            name: val
+          });
+        }
+      }
+    }
+  }
+  let name = options.name;
+  if (!name) {
+    const inferredName = inferPatternName(relativePaths);
+    console.log(chalk16.dim(`Inferred name: "${inferredName}"`));
+    const nameInput = await p11.text({
+      message: "Pattern name:",
+      placeholder: inferredName,
+      initialValue: inferredName,
+      validate: (value) => {
+        if (!value || value.length < 3) return "Name must be at least 3 characters";
+        if (value.length > 100) return "Name must be less than 100 characters";
+        return void 0;
+      }
+    });
+    if (p11.isCancel(nameInput)) {
+      p11.cancel("Capture cancelled");
+      process.exit(0);
+    }
+    name = nameInput;
+  }
+  let description = options.description;
+  if (!description) {
+    const descInput = await p11.text({
+      message: "Description:",
+      placeholder: "What does this pattern provide?",
+      validate: (value) => {
+        if (!value || value.length < 10) return "Description must be at least 10 characters";
+        if (value.length > 500) return "Description must be less than 500 characters";
+        return void 0;
+      }
+    });
+    if (p11.isCancel(descInput)) {
+      p11.cancel("Capture cancelled");
+      process.exit(0);
+    }
+    description = descInput;
+  }
+  let framework = options.framework;
+  if (!framework) {
+    const frameworkTag = uniqueTags.find((t) => t.category === "framework");
+    framework = frameworkTag?.name || "general";
+  }
+  if (uniqueTags.length > 0) {
+    console.log(chalk16.dim("\nInferred tags:"));
+    console.log(chalk16.dim(`  ${formatTags(uniqueTags)}`));
+  }
+  const files = [];
+  for (let i = 0; i < resolvedPaths.length; i++) {
+    const absolutePath = resolvedPaths[i];
+    const relativePath = relativePaths[i];
+    const content = fs2.readFileSync(absolutePath, "utf-8");
+    const ext = path2.extname(relativePath).slice(1);
+    const languageMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      mjs: "javascript",
+      cjs: "javascript",
+      py: "python",
+      go: "go",
+      rs: "rust",
+      css: "css",
+      scss: "scss",
+      html: "html",
+      json: "json",
+      yaml: "yaml",
+      yml: "yaml",
+      md: "markdown",
+      mdx: "mdx",
+      sql: "sql",
+      sh: "bash",
+      bash: "bash",
+      zsh: "bash"
+    };
+    files.push({
+      path: relativePath,
+      content,
+      language: languageMap[ext] || ext || "text"
+    });
+  }
+  const languageCounts = {};
+  for (const file of files) {
+    languageCounts[file.language] = (languageCounts[file.language] || 0) + 1;
+  }
+  const primaryLanguage = Object.entries(languageCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || "typescript";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const contributorManager = new ContributorManager2(cwd);
+  const contributorResult = await contributorManager.getOrCreateId();
+  const contributorId = contributorResult.success && contributorResult.data ? contributorResult.data : void 0;
+  const keyFiles = files.map((f) => ({
+    path: f.path,
+    purpose: `${f.language} file`,
+    content: f.content
+  }));
+  const blueprint = {
+    id: crypto.randomUUID(),
+    name,
+    description,
+    tags: uniqueTags,
+    stack: {
+      framework,
+      language: primaryLanguage,
+      runtime: "node",
+      packageManager: "pnpm",
+      dependencies: [],
+      devDependencies: []
+    },
+    structure: {
+      directories: [...new Set(files.map((f) => path2.dirname(f.path)).filter((d) => d !== "."))],
+      keyFiles
+    },
+    setup: {
+      prerequisites: [],
+      steps: [],
+      configs: []
+    },
+    compatibility: {
+      framework,
+      frameworkVersion: ">=1.0.0",
+      runtime: "node",
+      runtimeVersion: ">=18.0.0",
+      dependencies: []
+    },
+    metrics: {
+      applications: 0,
+      successes: 0,
+      failures: 0,
+      successRate: 0
+    },
+    relatedPatterns: [],
+    isPrivate: true,
+    contributorId,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (options.dryRun) {
+    console.log(chalk16.yellow("\n\u{1F50D} Dry Run - Would capture:\n"));
+    console.log(chalk16.bold(`Name: ${name}`));
+    console.log(chalk16.dim(`Description: ${description}`));
+    console.log(chalk16.dim(`Framework: ${framework}`));
+    console.log(chalk16.dim(`Tags: ${formatTags(uniqueTags)}`));
+    console.log(chalk16.dim(`Files: ${files.length}`));
+    console.log(chalk16.dim(`ID: ${blueprint.id}`));
+    console.log(chalk16.yellow("\n\u26A0\uFE0F  No changes made (dry run)"));
+    return;
+  }
+  const result = await store.saveBlueprint(blueprint);
+  if (!result.success) {
+    console.log(chalk16.red(`
+\u2717 Failed to save blueprint: ${result.error}`));
+    process.exit(1);
+  }
+  console.log(chalk16.green("\n\u2713 Blueprint captured successfully!\n"));
+  console.log(chalk16.bold(`ID: ${blueprint.id}`));
+  console.log(chalk16.dim(`Name: ${name}`));
+  console.log(chalk16.dim(`Files: ${files.length}`));
+  console.log(chalk16.dim(`Tags: ${formatTags(uniqueTags)}`));
+  console.log(chalk16.dim(`
+To apply this pattern:`));
+  console.log(chalk16.cyan(`  pnpm workflow:learn:apply ${blueprint.id}`));
+  console.log(chalk16.dim(`
+To publish to registry:`));
+  console.log(chalk16.cyan(`  pnpm workflow:learn:publish ${blueprint.id}`));
+}
+function getAllFilesInDir(dirPath) {
+  const files = [];
+  const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dirPath, entry.name);
+    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      files.push(...getAllFilesInDir(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
 
 // src/cli/commands/solution.ts
 import chalk17 from "chalk";
@@ -7172,14 +7622,11 @@ program.command("init").description("Initialize workflow in current project").op
   "--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(
+program.command("validate <type> [value]").description("Validate branch name, commit message, or PR title").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("config <action> [key] [value]").description("Manage workflow configuration").action(configCommand);
 program.command("config:fix").description("Automatically fix common configuration validation issues").action(async () => {
   const chalk18 = (await import("chalk")).default;
   const { autoFixConfigFile: autoFixConfigFile2 } = await import("../config/index.js");
@@ -7244,10 +7691,11 @@ program.command("learn:record").description("Record a new pattern from a success
   "Category (migration, security, performance, etc.)"
 ).option("--framework <fw>", "Framework (next, react, vue, etc.)").option("--version <ver>", "Framework version range").option("--tags <tags>", "Comma-separated tags (category:value)").option("--type <type>", "Pattern type (fix, blueprint)").action(learnRecordCommand);
 program.command("learn:list").description("List recorded learning patterns").option("--type <type>", "Filter by type (fix, blueprint, all)").option("--framework <fw>", "Filter by framework").option("--tag <tag>", "Filter by tag").option("--deprecated", "Include deprecated patterns").action(learnListCommand);
-program.command("learn:apply <patternId>").description("Apply a pattern to the current project").argument("<patternId>", "Pattern ID to apply").option("--framework <fw>", "Override framework").option("--version <ver>", "Override version").option("--dry-run", "Preview without applying").action(learnApplyCommand);
+program.command("learn:apply <patternId>").description("Apply a pattern to the current project").option("--framework <fw>", "Override framework").option("--version <ver>", "Override version").option("--dry-run", "Preview without applying").action(learnApplyCommand);
+program.command("learn:capture <paths...>").description("Capture files as a blueprint pattern with auto-inferred metadata").option("--name <name>", "Pattern name (inferred from paths if omitted)").option("--description <desc>", "Pattern description").option("--framework <fw>", "Override inferred framework").option("--tags <tags>", "Additional tags (comma-separated, e.g., 'framework:react,language:typescript')").option("--dry-run", "Preview what would be captured without saving").action(learnCaptureCommand);
 program.command("learn:sync").description("Sync patterns with remote registry").option("--push", "Push local patterns to registry").option("--pull", "Pull patterns from registry").option("--dry-run", "Preview without syncing").action(learnSyncCommand);
 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:deprecate <patternId> <reason>").description("Deprecate an outdated pattern").action(learnDeprecateCommand);
 program.command("learn:publish [patternId]").description("Mark pattern(s) as public for syncing").option("--private", "Mark as private instead of public").option("--all", "Apply to all patterns").option("-y, --yes", "Skip confirmation prompts").action(learnPublishCommand);
 program.command("learn:stats").description("Show learning statistics").action(learnStatsCommand);
 program.command("learn:validate").description("Validate pattern files and optionally auto-fix common issues").option(
@@ -7259,10 +7707,10 @@ program.command("solution:capture").description("Capture a solution pattern from
   "--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:search <query>").description("Search for solution patterns").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:apply <solutionId>").description("Apply a solution pattern to the current project").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").action(solutionDeprecateCommand);
 program.command("solution:stats").description("Show solution pattern statistics").action(solutionStatsCommand);
 program.parse();
 //# sourceMappingURL=index.js.map