workflow-agent-cli 2.3.0 → 2.4.0

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import {
   runAllChecks,
   runAllSetups,
   stageAllChanges
-} from "../chunk-YI3LBZ7I.js";
+} from "../chunk-WXXFUPYO.js";
 import {
   validateBranchName,
   validateCommitMessage,
@@ -1359,12 +1359,18 @@ describe('${presetName} Scope Preset (Migrated)', () => {
 // src/cli/commands/verify.ts
 import chalk9 from "chalk";
 import { execa as execa2 } from "execa";
+import {
+  PatternStore,
+  TelemetryCollector,
+  ContributorManager
+} from "@hawkinside_out/workflow-improvement-tracker";
 async function verifyCommand(options) {
   const cwd = process.cwd();
   const maxRetries = options.maxRetries ? parseInt(options.maxRetries, 10) : 10;
   const autoFix = options.fix ?? false;
   const shouldCommit = options.commit ?? false;
   const dryRun = options.dryRun ?? false;
+  const learnFromFixes = options.learn ?? false;
   console.log(chalk9.bold.cyan("\n\u{1F50D} Workflow Agent Quality Verification\n"));
   if (dryRun) {
     console.log(chalk9.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be applied\n"));
@@ -1373,6 +1379,7 @@ async function verifyCommand(options) {
   console.log(chalk9.dim(`  Max retries: ${maxRetries}`));
   console.log(chalk9.dim(`  Commit on success: ${shouldCommit ? "yes" : "no"}`));
   console.log(chalk9.dim(`  Dry-run: ${dryRun ? "yes" : "no"}`));
+  console.log(chalk9.dim(`  Learn from fixes: ${learnFromFixes ? "yes" : "no"}`));
   const startTime = Date.now();
   const result = await runAllChecks(cwd, {
     maxRetries,
@@ -1387,6 +1394,9 @@ ${"\u2501".repeat(50)}`);
     console.log(chalk9.dim(`  Total time: ${totalTime}s`));
     console.log(chalk9.dim(`  Validation cycles: ${result.totalAttempts}`));
     console.log(chalk9.dim(`  Fixes applied: ${result.fixesApplied}`));
+    if (learnFromFixes && result.fixesApplied > 0 && !dryRun) {
+      await recordSuccessfulFixes(cwd, result);
+    }
     if (shouldCommit) {
       const hasChanges = await hasUncommittedChanges(cwd);
       if (hasChanges) {
@@ -1441,6 +1451,132 @@ ${"\u2501".repeat(50)}`);
     process.exit(1);
   }
 }
+async function recordSuccessfulFixes(cwd, result) {
+  try {
+    const contributorManager = new ContributorManager(cwd);
+    const telemetryEnabled = await contributorManager.isTelemetryEnabled();
+    if (!telemetryEnabled) {
+      return;
+    }
+    const store = new PatternStore(cwd);
+    const telemetry = new TelemetryCollector(cwd);
+    let framework = "unknown";
+    let frameworkVersion = "0.0.0";
+    try {
+      const fs2 = await import("fs");
+      const path2 = await import("path");
+      const packageJsonPath = path2.join(cwd, "package.json");
+      const packageJson = JSON.parse(
+        await fs2.promises.readFile(packageJsonPath, "utf-8")
+      );
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (deps["next"]) {
+        framework = "next";
+        frameworkVersion = deps["next"].replace(/[\^~]/, "");
+      } else if (deps["react"]) {
+        framework = "react";
+        frameworkVersion = deps["react"].replace(/[\^~]/, "");
+      } else if (deps["vue"]) {
+        framework = "vue";
+        frameworkVersion = deps["vue"].replace(/[\^~]/, "");
+      } else if (deps["express"]) {
+        framework = "express";
+        frameworkVersion = deps["express"].replace(/[\^~]/, "");
+      }
+    } catch {
+    }
+    if (result.appliedFixes && result.appliedFixes.length > 0) {
+      console.log(chalk9.cyan("\n\u{1F4DA} Recording successful fixes for learning...\n"));
+      for (const fix of result.appliedFixes) {
+        const patternName = `Auto-fix: ${fix.displayName}`;
+        const patternId = crypto.randomUUID();
+        const existingPatterns = await store.listFixPatterns({
+          tags: [{ category: "tool", name: fix.checkName }]
+        });
+        if (existingPatterns.success && existingPatterns.data && existingPatterns.data.length > 0) {
+          const existingPattern = existingPatterns.data[0];
+          await store.updateFixMetrics(existingPattern.id, true);
+          await telemetry.recordSuccess(
+            existingPattern.id,
+            "fix",
+            framework,
+            frameworkVersion
+          );
+          console.log(chalk9.dim(`  \u2713 Updated: ${existingPattern.name}`));
+        } else {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const newPattern = {
+            id: patternId,
+            name: patternName,
+            description: `Auto-fix pattern for ${fix.displayName} using command: ${fix.command}`,
+            category: "config",
+            tags: [
+              { category: "tool", name: fix.checkName },
+              { category: "framework", name: framework }
+            ],
+            trigger: {
+              errorPattern: fix.checkName,
+              errorMessage: `${fix.checkName} check failed`,
+              filePattern: "**/*"
+            },
+            solution: {
+              type: "command",
+              steps: [
+                {
+                  order: 1,
+                  action: "run",
+                  target: fix.command,
+                  description: `Run ${fix.command}`
+                }
+              ]
+            },
+            compatibility: {
+              framework,
+              frameworkVersion: `>=${frameworkVersion}`,
+              runtime: "node",
+              runtimeVersion: ">=18.0.0",
+              dependencies: []
+            },
+            metrics: {
+              applications: 1,
+              successes: 1,
+              failures: 0,
+              successRate: 100,
+              lastUsed: now,
+              lastSuccessful: now
+            },
+            source: "verify-fix",
+            isPrivate: true,
+            createdAt: now,
+            updatedAt: now
+          };
+          const saveResult = await store.saveFixPattern(newPattern);
+          if (saveResult.success) {
+            await telemetry.recordSuccess(
+              patternId,
+              "fix",
+              framework,
+              frameworkVersion
+            );
+            console.log(chalk9.dim(`  \u2713 Recorded: ${patternName}`));
+          }
+        }
+      }
+      console.log(
+        chalk9.dim(`
+  Use 'workflow learn:list' to see recorded patterns.`)
+      );
+    }
+  } catch (error) {
+    console.log(
+      chalk9.dim(`
+  Note: Could not record learning patterns: ${error.message}`)
+    );
+  }
+}
 
 // src/cli/commands/auto-setup-command.ts
 import * as p6 from "@clack/prompts";
@@ -1588,6 +1724,596 @@ function formatAuditReportColored(report) {
   return lines.join("\n");
 }
 
+// src/cli/commands/learn.ts
+import chalk11 from "chalk";
+import * as p7 from "@clack/prompts";
+import {
+  PatternStore as PatternStore2,
+  ContributorManager as ContributorManager2,
+  PatternAnonymizer,
+  TelemetryCollector as TelemetryCollector2
+} from "@hawkinside_out/workflow-improvement-tracker";
+function getWorkspacePath() {
+  return process.cwd();
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatTags(tags) {
+  return tags.map((t) => `${t.category}:${t.name}`).join(", ");
+}
+async function learnRecordCommand(options) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  console.log(chalk11.cyan("\n\u{1F4DA} Record a Learning Pattern\n"));
+  let patternType = options.type;
+  if (!patternType) {
+    const typeChoice = await p7.select({
+      message: "What type of pattern are you recording?",
+      options: [
+        {
+          value: "fix",
+          label: "\u{1F527} Fix Pattern - A specific solution to a problem"
+        },
+        {
+          value: "blueprint",
+          label: "\u{1F4D0} Blueprint - A project structure template"
+        }
+      ]
+    });
+    if (p7.isCancel(typeChoice)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    patternType = typeChoice;
+  }
+  let name = options.name;
+  if (!name) {
+    const nameInput = await p7.text({
+      message: "Pattern name:",
+      placeholder: "e.g., Next.js App Router Migration",
+      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 (p7.isCancel(nameInput)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    name = nameInput;
+  }
+  let description = options.description;
+  if (!description) {
+    const descInput = await p7.text({
+      message: "Description:",
+      placeholder: "What does this pattern solve?",
+      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 (p7.isCancel(descInput)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    description = descInput;
+  }
+  let framework = options.framework;
+  if (!framework) {
+    const fwInput = await p7.text({
+      message: "Framework:",
+      placeholder: "e.g., next, react, vue, express"
+    });
+    if (p7.isCancel(fwInput)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    framework = fwInput;
+  }
+  let version = options.version;
+  if (!version) {
+    const versionInput = await p7.text({
+      message: "Framework version (semver range):",
+      placeholder: "e.g., >=14.0.0, ^18.0.0",
+      initialValue: ">=1.0.0"
+    });
+    if (p7.isCancel(versionInput)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    version = versionInput;
+  }
+  let category = options.category;
+  if (patternType === "fix" && !category) {
+    const catChoice = await p7.select({
+      message: "Category:",
+      options: [
+        { value: "migration", label: "\u{1F504} Migration" },
+        { value: "security", label: "\u{1F512} Security" },
+        { value: "performance", label: "\u26A1 Performance" },
+        { value: "compatibility", label: "\u{1F517} Compatibility" },
+        { value: "deprecation", label: "\u26A0\uFE0F Deprecation" },
+        { value: "configuration", label: "\u2699\uFE0F Configuration" },
+        { value: "best-practice", label: "\u2728 Best Practice" },
+        { value: "error-handling", label: "\u{1F6A8} Error Handling" },
+        { value: "testing", label: "\u{1F9EA} Testing" },
+        { value: "other", label: "\u{1F4E6} Other" }
+      ]
+    });
+    if (p7.isCancel(catChoice)) {
+      p7.cancel("Recording cancelled");
+      process.exit(0);
+    }
+    category = catChoice;
+  }
+  const tags = [];
+  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) {
+        tags.push({
+          category: cat,
+          name: val
+        });
+      }
+    }
+  }
+  tags.push({ category: "framework", name: framework });
+  if (patternType === "fix") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fixPattern = {
+      id: crypto.randomUUID(),
+      name,
+      description,
+      category,
+      tags,
+      trigger: {
+        errorPattern: ".*",
+        errorMessage: "Generic error pattern",
+        filePattern: "**/*"
+      },
+      solution: {
+        type: "command",
+        steps: [
+          {
+            order: 1,
+            action: "run",
+            target: "npm run fix",
+            description: "Follow the pattern instructions"
+          }
+        ]
+      },
+      compatibility: {
+        framework,
+        frameworkVersion: version,
+        runtime: "node",
+        runtimeVersion: ">=18.0.0",
+        dependencies: []
+      },
+      metrics: {
+        applications: 0,
+        successes: 0,
+        failures: 0,
+        successRate: 0
+      },
+      source: "manual",
+      isPrivate: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    const result = await store.saveFixPattern(fixPattern);
+    if (result.success) {
+      console.log(chalk11.green("\n\u2705 Fix pattern recorded successfully!\n"));
+      console.log(chalk11.dim(`  ID: ${fixPattern.id}`));
+      console.log(chalk11.dim(`  Name: ${name}`));
+      console.log(chalk11.dim(`  Category: ${category}`));
+      console.log(chalk11.dim(`  Framework: ${framework} ${version}`));
+    } else {
+      console.log(chalk11.red("\n\u274C Failed to record pattern"));
+      console.log(chalk11.dim(`  Error: ${result.error}`));
+      process.exit(1);
+    }
+  } else {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const blueprint = {
+      id: crypto.randomUUID(),
+      name,
+      description,
+      tags,
+      stack: {
+        framework,
+        language: "typescript",
+        runtime: "node",
+        packageManager: "pnpm",
+        dependencies: [],
+        devDependencies: []
+      },
+      structure: {
+        directories: [],
+        keyFiles: []
+      },
+      setup: {
+        prerequisites: [],
+        steps: [],
+        configs: []
+      },
+      compatibility: {
+        framework,
+        frameworkVersion: version,
+        runtime: "node",
+        runtimeVersion: ">=18.0.0",
+        dependencies: []
+      },
+      metrics: {
+        applications: 0,
+        successes: 0,
+        failures: 0,
+        successRate: 0
+      },
+      relatedPatterns: [],
+      isPrivate: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    const result = await store.saveBlueprint(blueprint);
+    if (result.success) {
+      console.log(chalk11.green("\n\u2705 Blueprint recorded successfully!\n"));
+      console.log(chalk11.dim(`  ID: ${blueprint.id}`));
+      console.log(chalk11.dim(`  Name: ${name}`));
+      console.log(chalk11.dim(`  Framework: ${framework} ${version}`));
+    } else {
+      console.log(chalk11.red("\n\u274C Failed to record blueprint"));
+      console.log(chalk11.dim(`  Error: ${result.error}`));
+      process.exit(1);
+    }
+  }
+}
+async function learnListCommand(options) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  const patternType = options.type ?? "all";
+  const showDeprecated = options.deprecated ?? false;
+  console.log(chalk11.cyan("\n\u{1F4DA} Recorded Learning Patterns\n"));
+  if (patternType === "all" || patternType === "fix") {
+    const fixResult = await store.listFixPatterns({
+      tags: options.tag ? [{ category: "framework", name: options.tag }] : void 0,
+      framework: options.framework,
+      includeDeprecated: showDeprecated
+    });
+    if (fixResult.success && fixResult.data && fixResult.data.length > 0) {
+      console.log(chalk11.bold.yellow("\u{1F527} Fix Patterns:\n"));
+      for (const pattern of fixResult.data) {
+        const isDeprecated = pattern.deprecatedAt !== void 0;
+        const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
+        const nameColor = isDeprecated ? chalk11.dim : chalk11.white;
+        console.log(`  ${statusIcon} ${nameColor(pattern.name)}`);
+        console.log(chalk11.dim(`     ID: ${pattern.id}`));
+        console.log(chalk11.dim(`     Category: ${pattern.category}`));
+        console.log(chalk11.dim(`     Created: ${formatDate(pattern.createdAt)}`));
+        console.log(
+          chalk11.dim(
+            `     Success Rate: ${(pattern.metrics.successRate * 100).toFixed(0)}% (${pattern.metrics.successes}/${pattern.metrics.applications})`
+          )
+        );
+        if (pattern.tags.length > 0) {
+          console.log(chalk11.dim(`     Tags: ${formatTags(pattern.tags)}`));
+        }
+        console.log("");
+      }
+    } else if (patternType === "fix") {
+      console.log(chalk11.dim("  No fix patterns found.\n"));
+    }
+  }
+  if (patternType === "all" || patternType === "blueprint") {
+    const bpResult = await store.listBlueprints({
+      tags: options.tag ? [{ category: "framework", name: options.tag }] : void 0,
+      framework: options.framework,
+      includeDeprecated: showDeprecated
+    });
+    if (bpResult.success && bpResult.data && bpResult.data.length > 0) {
+      console.log(chalk11.bold.blue("\u{1F4D0} Blueprints:\n"));
+      for (const blueprint of bpResult.data) {
+        const isDeprecated = blueprint.deprecatedAt !== void 0;
+        const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
+        const nameColor = isDeprecated ? chalk11.dim : chalk11.white;
+        console.log(`  ${statusIcon} ${nameColor(blueprint.name)}`);
+        console.log(chalk11.dim(`     ID: ${blueprint.id}`));
+        console.log(chalk11.dim(`     Language: ${blueprint.stack.language}`));
+        console.log(chalk11.dim(`     Created: ${formatDate(blueprint.createdAt)}`));
+        console.log(
+          chalk11.dim(
+            `     Success Rate: ${(blueprint.metrics.successRate * 100).toFixed(0)}% (${blueprint.metrics.successes}/${blueprint.metrics.applications})`
+          )
+        );
+        if (blueprint.tags.length > 0) {
+          console.log(chalk11.dim(`     Tags: ${formatTags(blueprint.tags)}`));
+        }
+        console.log("");
+      }
+    } else if (patternType === "blueprint") {
+      console.log(chalk11.dim("  No blueprints found.\n"));
+    }
+  }
+  const stats = await store.getStats();
+  const totalPatterns = stats.totalFixes + stats.totalBlueprints;
+  const totalDeprecated = stats.deprecatedFixes + stats.deprecatedBlueprints;
+  console.log(chalk11.dim("\u2501".repeat(40)));
+  console.log(chalk11.dim(`Total: ${totalPatterns} patterns`));
+  console.log(chalk11.dim(`  Fix Patterns: ${stats.totalFixes}`));
+  console.log(chalk11.dim(`  Blueprints: ${stats.totalBlueprints}`));
+  console.log(chalk11.dim(`  Deprecated: ${totalDeprecated}`));
+  console.log("");
+}
+async function learnApplyCommand(patternId, options) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  const telemetry = new TelemetryCollector2(cwd);
+  console.log(chalk11.cyan("\n\u{1F527} Apply Learning Pattern\n"));
+  let pattern = await store.getFixPattern(patternId);
+  let patternType = "fix";
+  if (!pattern.success || !pattern.data) {
+    const bpResult = await store.getBlueprint(patternId);
+    if (bpResult.success && bpResult.data) {
+      pattern = bpResult;
+      patternType = "blueprint";
+    } else {
+      console.log(chalk11.red(`
+\u274C Pattern not found: ${patternId}`));
+      console.log(chalk11.dim("  Use 'workflow learn:list' to see available patterns"));
+      process.exit(1);
+    }
+  }
+  const patternData = pattern.data;
+  console.log(chalk11.white(`  Pattern: ${patternData.name}`));
+  console.log(chalk11.dim(`  Type: ${patternType}`));
+  console.log(chalk11.dim(`  Description: ${patternData.description}`));
+  if (options.dryRun) {
+    console.log(chalk11.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";
+  await telemetry.recordApplication(patternId, patternType, framework, version);
+  if (patternType === "fix") {
+    const fixPattern = patternData;
+    console.log(chalk11.cyan("\n\u{1F4CB} Solution Steps:\n"));
+    if (fixPattern.solution.steps) {
+      for (let i = 0; i < fixPattern.solution.steps.length; i++) {
+        const step = fixPattern.solution.steps[i];
+        console.log(chalk11.white(`  ${i + 1}. [${step.action}] ${step.description}`));
+        if (step.file) {
+          console.log(chalk11.dim(`     File: ${step.file}`));
+        }
+      }
+    }
+  } else {
+    const blueprint = patternData;
+    console.log(chalk11.cyan("\n\u{1F4CB} Setup Steps:\n"));
+    if (blueprint.setup.steps) {
+      for (let i = 0; i < blueprint.setup.steps.length; i++) {
+        const step = blueprint.setup.steps[i];
+        console.log(chalk11.white(`  ${i + 1}. ${step.description}`));
+        if (step.command) {
+          console.log(chalk11.dim(`     Command: ${step.command}`));
+        }
+      }
+    }
+  }
+  if (!options.dryRun) {
+    const confirmed = await p7.confirm({
+      message: "Mark this pattern as successfully applied?",
+      initialValue: true
+    });
+    if (p7.isCancel(confirmed)) {
+      p7.cancel("Application cancelled");
+      process.exit(0);
+    }
+    if (confirmed) {
+      await store.updatePatternMetrics(patternId, patternType, true);
+      await telemetry.recordSuccess(patternId, patternType, framework, version);
+      console.log(chalk11.green("\n\u2705 Pattern marked as successfully applied!"));
+    } else {
+      await store.updatePatternMetrics(patternId, patternType, false);
+      await telemetry.recordFailure(patternId, patternType, framework, version, "unknown");
+      console.log(chalk11.yellow("\n\u26A0\uFE0F Pattern application marked as unsuccessful."));
+    }
+  }
+}
+async function learnSyncCommand(options) {
+  const cwd = getWorkspacePath();
+  const contributorManager = new ContributorManager2(cwd);
+  console.log(chalk11.cyan("\n\u{1F504} Sync Learning Patterns\n"));
+  const config = await contributorManager.getConfig();
+  if (!config.success || !config.data?.syncOptIn) {
+    console.log(chalk11.yellow("\u26A0\uFE0F Sync is not enabled.\n"));
+    console.log(chalk11.dim("  To enable sync, run:"));
+    console.log(chalk11.dim("    workflow learn:config --enable-sync\n"));
+    console.log(chalk11.dim("  This allows you to share anonymized patterns with the community."));
+    process.exit(0);
+  }
+  if (options.dryRun) {
+    console.log(chalk11.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be synced\n"));
+  }
+  const store = new PatternStore2(cwd);
+  const anonymizer = new PatternAnonymizer();
+  const { fixes, blueprints } = await store.getPatternsForSync();
+  console.log(chalk11.dim(`  Patterns ready to sync: ${fixes.length} fixes, ${blueprints.length} blueprints`));
+  if (options.push) {
+    console.log(chalk11.cyan("\n\u{1F4E4} Pushing patterns...\n"));
+    let anonymizedFixes = 0;
+    let anonymizedBlueprints = 0;
+    for (const fix of fixes) {
+      const result = anonymizer.anonymizeFixPattern(fix);
+      if (result.success) {
+        anonymizedFixes++;
+        if (!options.dryRun) {
+          console.log(chalk11.dim(`  \u2713 Anonymized: ${fix.name}`));
+        }
+      }
+    }
+    for (const bp of blueprints) {
+      const result = anonymizer.anonymizeBlueprint(bp);
+      if (result.success) {
+        anonymizedBlueprints++;
+        if (!options.dryRun) {
+          console.log(chalk11.dim(`  \u2713 Anonymized: ${bp.name}`));
+        }
+      }
+    }
+    console.log(
+      chalk11.green(`
+\u2705 Ready to push ${anonymizedFixes} fixes and ${anonymizedBlueprints} blueprints`)
+    );
+    console.log(chalk11.dim("  (Registry push not yet implemented)"));
+  }
+  if (options.pull) {
+    console.log(chalk11.cyan("\n\u{1F4E5} Pulling patterns from registry...\n"));
+    console.log(chalk11.dim("  (Registry pull not yet implemented)"));
+  }
+  if (!options.push && !options.pull) {
+    console.log(chalk11.dim("  Specify --push to upload or --pull to download patterns.\n"));
+  }
+}
+async function learnConfigCommand(options) {
+  const cwd = getWorkspacePath();
+  const contributorManager = new ContributorManager2(cwd);
+  console.log(chalk11.cyan("\n\u2699\uFE0F Learning Configuration\n"));
+  if (options.enableSync) {
+    const result = await contributorManager.enableSync();
+    if (result.success) {
+      console.log(chalk11.green("\u2705 Sync enabled"));
+      console.log(chalk11.dim("  Your patterns will be anonymized before sharing."));
+    } else {
+      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+    }
+    return;
+  }
+  if (options.disableSync) {
+    const result = await contributorManager.disableSync();
+    if (result.success) {
+      console.log(chalk11.green("\u2705 Sync disabled"));
+    } else {
+      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+    }
+    return;
+  }
+  if (options.enableTelemetry) {
+    const result = await contributorManager.enableTelemetry();
+    if (result.success) {
+      console.log(chalk11.green("\u2705 Telemetry enabled"));
+      console.log(chalk11.dim("  Anonymous usage data helps improve pattern recommendations."));
+    } else {
+      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+    }
+    return;
+  }
+  if (options.disableTelemetry) {
+    const result = await contributorManager.disableTelemetry();
+    if (result.success) {
+      console.log(chalk11.green("\u2705 Telemetry disabled"));
+    } else {
+      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+    }
+    return;
+  }
+  if (options.resetId) {
+    const confirmed = await p7.confirm({
+      message: "Are you sure you want to reset your contributor ID? This cannot be undone.",
+      initialValue: false
+    });
+    if (p7.isCancel(confirmed) || !confirmed) {
+      p7.cancel("Reset cancelled");
+      return;
+    }
+    const result = await contributorManager.resetId();
+    if (result.success) {
+      console.log(chalk11.green("\u2705 Contributor ID reset"));
+      console.log(chalk11.dim(`  New ID: ${result.data?.id}`));
+    } else {
+      console.log(chalk11.red(`\u274C Failed: ${result.error}`));
+    }
+    return;
+  }
+  const config = await contributorManager.getConfig();
+  if (config.success && config.data) {
+    console.log(chalk11.white("  Current Settings:\n"));
+    console.log(chalk11.dim(`  Contributor ID: ${config.data.id}`));
+    console.log(chalk11.dim(`  Created: ${formatDate(config.data.createdAt)}`));
+    console.log(chalk11.dim(`  Sync Enabled: ${config.data.syncOptIn ? "Yes" : "No"}`));
+    console.log(chalk11.dim(`  Telemetry Enabled: ${config.data.telemetryEnabled ? "Yes" : "No"}`));
+    if (config.data.syncEnabledAt) {
+      console.log(chalk11.dim(`  Sync Enabled At: ${formatDate(config.data.syncEnabledAt)}`));
+    }
+  } else {
+    console.log(chalk11.dim("  No configuration found. Settings will be created on first use.\n"));
+  }
+}
+async function learnDeprecateCommand(patternId, reason) {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  console.log(chalk11.cyan("\n\u26A0\uFE0F Deprecate Pattern\n"));
+  let patternType = "fix";
+  let pattern = await store.getFixPattern(patternId);
+  if (!pattern.success || !pattern.data) {
+    const bpResult = await store.getBlueprint(patternId);
+    if (bpResult.success && bpResult.data) {
+      pattern = bpResult;
+      patternType = "blueprint";
+    } else {
+      console.log(chalk11.red(`
+\u274C Pattern not found: ${patternId}`));
+      process.exit(1);
+    }
+  }
+  console.log(chalk11.white(`  Pattern: ${pattern.data.name}`));
+  console.log(chalk11.dim(`  Reason: ${reason}`));
+  const confirmed = await p7.confirm({
+    message: "Are you sure you want to deprecate this pattern?",
+    initialValue: false
+  });
+  if (p7.isCancel(confirmed) || !confirmed) {
+    p7.cancel("Deprecation cancelled");
+    return;
+  }
+  const result = await store.deprecatePattern(patternId, patternType, reason);
+  if (result.success) {
+    console.log(chalk11.green("\n\u2705 Pattern deprecated successfully"));
+  } else {
+    console.log(chalk11.red(`
+\u274C Failed: ${result.error}`));
+    process.exit(1);
+  }
+}
+async function learnStatsCommand() {
+  const cwd = getWorkspacePath();
+  const store = new PatternStore2(cwd);
+  const telemetry = new TelemetryCollector2(cwd);
+  console.log(chalk11.cyan("\n\u{1F4CA} Learning Statistics\n"));
+  const storeStats = await store.getStats();
+  const totalPatterns = storeStats.totalFixes + storeStats.totalBlueprints;
+  const totalDeprecated = storeStats.deprecatedFixes + storeStats.deprecatedBlueprints;
+  console.log(chalk11.bold.white("  Patterns:\n"));
+  console.log(chalk11.dim(`    Total: ${totalPatterns}`));
+  console.log(chalk11.dim(`    Fix Patterns: ${storeStats.totalFixes}`));
+  console.log(chalk11.dim(`    Blueprints: ${storeStats.totalBlueprints}`));
+  console.log(chalk11.dim(`    Deprecated: ${totalDeprecated}`));
+  const telemetryStats = await telemetry.getStats();
+  console.log(chalk11.bold.white("\n  Telemetry:\n"));
+  console.log(chalk11.dim(`    Pending Events: ${telemetryStats.pendingEvents}`));
+  console.log(chalk11.dim(`    Total Events Sent: ${telemetryStats.totalEventsSent}`));
+  if (telemetryStats.lastFlushAt) {
+    console.log(chalk11.dim(`    Last Flush: ${formatDate(telemetryStats.lastFlushAt)}`));
+  }
+  console.log("");
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("workflow").description(
@@ -1616,7 +2342,14 @@ program.command("scope:create").description("Create a custom scope package").opt
   "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.command("verify").description("Run all quality checks with fix-and-revalidate pattern").option("--fix", "Enable auto-fix for lint and format issues").option("--max-retries <n>", "Maximum retry cycles (default: 10)", "10").option("--commit", "Commit changes if all checks pass").option("--dry-run", "Preview fixes without applying them").action(verifyCommand);
+program.command("verify").description("Run all quality checks with fix-and-revalidate pattern").option("--fix", "Enable auto-fix for lint and format issues").option("--max-retries <n>", "Maximum retry cycles (default: 10)", "10").option("--commit", "Commit changes if all checks pass").option("--dry-run", "Preview fixes without applying them").option("--learn", "Record successful fixes as learning patterns").action(verifyCommand);
 program.command("auto-setup").description("Automatically configure linting, formatting, testing, and CI").option("-y, --yes", "Auto-approve all prompts").option("--audit", "Show audit report without applying changes").action(autoSetupCommand);
+program.command("learn:record").description("Record a new pattern from a successful implementation").option("--name <name>", "Pattern name").option("--description <desc>", "Pattern description").option("--category <cat>", "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: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:stats").description("Show learning statistics").action(learnStatsCommand);
 program.parse();
 //# sourceMappingURL=index.js.map