workflow-agent-cli 2.14.1 → 2.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Workflow Agent Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli/index.js

@@ -58,8 +58,8 @@ var adapters = {
     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");
+      const fs3 = await import("fs");
+      return fs3.existsSync("app") && fs3.existsSync("next.config.ts") || fs3.existsSync("next.config.js");
     },
     paths: {
       actions: "app/actions",
@@ -75,8 +75,8 @@ var adapters = {
     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"));
+      const fs3 = await import("fs");
+      return fs3.existsSync("pages") && (fs3.existsSync("next.config.ts") || fs3.existsSync("next.config.js"));
     },
     paths: {
       components: "components",
@@ -91,8 +91,8 @@ var adapters = {
     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");
+      const fs3 = await import("fs");
+      return fs3.existsSync("vite.config.ts") || fs3.existsSync("vite.config.js");
     },
     paths: {
       components: "src/components",
@@ -107,8 +107,8 @@ var adapters = {
     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"));
+      const fs3 = await import("fs");
+      return fs3.existsSync("app/routes") && (fs3.existsSync("remix.config.js") || fs3.existsSync("package.json"));
     },
     paths: {
       components: "app/components",
@@ -122,8 +122,8 @@ var adapters = {
     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");
+      const fs3 = await import("fs");
+      return fs3.existsSync("astro.config.mjs") || fs3.existsSync("astro.config.ts");
     },
     paths: {
       components: "src/components",
@@ -137,8 +137,8 @@ var adapters = {
     name: "SvelteKit",
     description: "SvelteKit full-stack framework",
     detect: async () => {
-      const fs2 = await import("fs");
-      return fs2.existsSync("svelte.config.js") || fs2.existsSync("src/routes");
+      const fs3 = await import("fs");
+      return fs3.existsSync("svelte.config.js") || fs3.existsSync("src/routes");
     },
     paths: {
       components: "src/lib/components",
@@ -1817,11 +1817,11 @@ async function recordSuccessfulFixes(cwd, result) {
     let framework = "unknown";
     let frameworkVersion = "0.0.0";
     try {
-      const fs2 = await import("fs");
-      const path3 = await import("path");
-      const packageJsonPath = path3.join(cwd, "package.json");
+      const fs3 = await import("fs");
+      const path4 = await import("path");
+      const packageJsonPath = path4.join(cwd, "package.json");
       const packageJson = JSON.parse(
-        await fs2.promises.readFile(packageJsonPath, "utf-8")
+        await fs3.promises.readFile(packageJsonPath, "utf-8")
       );
       const deps = {
         ...packageJson.dependencies,
@@ -5226,11 +5226,17 @@ async function statusHooksAction(cwd) {
 // src/cli/commands/learn.ts
 import chalk16 from "chalk";
 import * as p11 from "@clack/prompts";
+import * as fs2 from "fs";
+import * as path2 from "path";
 import {
   PatternStore as PatternStore2,
   ContributorManager as ContributorManager2,
   PatternAnonymizer,
-  TelemetryCollector as TelemetryCollector2
+  TelemetryCollector as TelemetryCollector2,
+  FixPatternSchema,
+  BlueprintSchema,
+  SolutionPatternSchema,
+  createDefaultMetrics
 } from "@hawkinside_out/workflow-improvement-tracker";
 
 // src/sync/registry-client.ts
@@ -5335,8 +5341,8 @@ var RegistryClient = class {
   /**
    * Make an HTTP request to the registry
    */
-  async request(path3, options) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(path4, options) {
+    const url = `${this.baseUrl}${path4}`;
     let lastError = null;
     for (let attempt = 1; attempt <= this.retries; attempt++) {
       try {
@@ -5739,11 +5745,63 @@ async function learnListCommand(options) {
   const stats = await store.getStats();
   const totalPatterns = stats.totalFixes + stats.totalBlueprints;
   const totalDeprecated = stats.deprecatedFixes + stats.deprecatedBlueprints;
+  const totalInvalid = stats.invalidFixes + stats.invalidBlueprints + stats.invalidSolutions;
   console.log(chalk16.dim("\u2501".repeat(40)));
   console.log(chalk16.dim(`Total: ${totalPatterns} patterns`));
   console.log(chalk16.dim(`  Fix Patterns: ${stats.totalFixes}`));
   console.log(chalk16.dim(`  Blueprints: ${stats.totalBlueprints}`));
   console.log(chalk16.dim(`  Deprecated: ${totalDeprecated}`));
+  if (totalInvalid > 0) {
+    console.log(
+      chalk16.yellow(
+        `
+\u26A0\uFE0F  ${totalInvalid} pattern(s) failed schema validation and were skipped:`
+      )
+    );
+    console.log(
+      chalk16.dim(`     Fix patterns: ${stats.invalidFixes} invalid`)
+    );
+    console.log(
+      chalk16.dim(`     Blueprints: ${stats.invalidBlueprints} invalid`)
+    );
+    console.log(
+      chalk16.dim(`     Solutions: ${stats.invalidSolutions} invalid`)
+    );
+    const validationErrors = store.getValidationErrors();
+    if (validationErrors.length > 0) {
+      console.log(chalk16.yellow("\n   Validation errors:"));
+      for (const err of validationErrors.slice(0, 5)) {
+        console.log(chalk16.dim(`     \u2022 ${err.file}: ${err.error}`));
+        if (err.details && err.details.length > 0) {
+          for (const detail of err.details.slice(0, 3)) {
+            console.log(chalk16.dim(`       - ${detail}`));
+          }
+          if (err.details.length > 3) {
+            console.log(
+              chalk16.dim(`       ... and ${err.details.length - 3} more`)
+            );
+          }
+        }
+      }
+      if (validationErrors.length > 5) {
+        console.log(
+          chalk16.dim(
+            `     ... and ${validationErrors.length - 5} more errors`
+          )
+        );
+      }
+    }
+    console.log(
+      chalk16.dim(
+        "\n   Tip: Invalid patterns may be missing required fields. Use the PatternStore API"
+      )
+    );
+    console.log(
+      chalk16.dim(
+        "        to create patterns instead of writing JSON files directly."
+      )
+    );
+  }
   console.log("");
 }
 async function learnApplyCommand(patternId, options) {
@@ -6382,11 +6440,294 @@ async function learnStatsCommand() {
   }
   console.log("");
 }
+async function learnValidateCommand(options) {
+  const cwd = getWorkspacePath();
+  const patternsPath = path2.join(cwd, ".workflow", "patterns");
+  const patternType = options.type ?? "all";
+  const shouldFix = options.fix ?? false;
+  const verbose = options.verbose ?? false;
+  const specificFile = options.file;
+  console.log(chalk16.cyan("\n\u{1F50D} Validating Pattern Files\n"));
+  const results = [];
+  if (specificFile) {
+    const fileResult = await validateSingleFile(specificFile, verbose);
+    if (fileResult) {
+      results.push(fileResult);
+    }
+  } else {
+    if (patternType === "all" || patternType === "fix") {
+      const fixesPath = path2.join(patternsPath, "fixes");
+      const fixResults = await validatePatternDirectory(
+        fixesPath,
+        "fix",
+        FixPatternSchema,
+        verbose
+      );
+      results.push(...fixResults);
+    }
+    if (patternType === "all" || patternType === "blueprint") {
+      const blueprintsPath = path2.join(patternsPath, "blueprints");
+      const bpResults = await validatePatternDirectory(
+        blueprintsPath,
+        "blueprint",
+        BlueprintSchema,
+        verbose
+      );
+      results.push(...bpResults);
+    }
+    if (patternType === "all" || patternType === "solution") {
+      const solutionsPath = path2.join(patternsPath, "solutions");
+      const solResults = await validatePatternDirectory(
+        solutionsPath,
+        "solution",
+        SolutionPatternSchema,
+        verbose
+      );
+      results.push(...solResults);
+    }
+  }
+  const valid = results.filter((r) => r.valid);
+  const invalid = results.filter((r) => !r.valid);
+  const fixable = invalid.filter((r) => r.fixable);
+  console.log(chalk16.dim("\u2501".repeat(50)));
+  console.log(chalk16.bold(`
+\u{1F4CA} Validation Summary
+`));
+  console.log(chalk16.green(`  \u2713 Valid: ${valid.length}`));
+  if (invalid.length > 0) {
+    console.log(chalk16.red(`  \u2717 Invalid: ${invalid.length}`));
+    console.log(chalk16.yellow(`  \u{1F527} Auto-fixable: ${fixable.length}`));
+  }
+  if (invalid.length > 0) {
+    console.log(chalk16.red(`
+\u274C Invalid Patterns:
+`));
+    for (const result of invalid) {
+      console.log(chalk16.white(`  ${result.file} (${result.type})`));
+      for (const err of result.errors.slice(0, 5)) {
+        console.log(chalk16.dim(`    - ${err}`));
+      }
+      if (result.errors.length > 5) {
+        console.log(chalk16.dim(`    ... and ${result.errors.length - 5} more`));
+      }
+      if (result.fixable) {
+        console.log(chalk16.yellow(`    \u2192 Can be auto-fixed`));
+      }
+    }
+  }
+  if (shouldFix && fixable.length > 0) {
+    console.log(chalk16.cyan(`
+\u{1F527} Auto-fixing ${fixable.length} patterns...
+`));
+    let fixed = 0;
+    for (const result of fixable) {
+      if (result.fixedData) {
+        const filePath = path2.join(
+          patternsPath,
+          result.type === "fix" ? "fixes" : result.type === "blueprint" ? "blueprints" : "solutions",
+          result.file
+        );
+        try {
+          await fs2.promises.writeFile(
+            filePath,
+            JSON.stringify(result.fixedData, null, 2)
+          );
+          console.log(chalk16.green(`  \u2713 Fixed: ${result.file}`));
+          fixed++;
+        } catch (error) {
+          console.log(
+            chalk16.red(
+              `  \u2717 Failed to fix: ${result.file} - ${error instanceof Error ? error.message : "Unknown error"}`
+            )
+          );
+        }
+      }
+    }
+    console.log(chalk16.green(`
+\u2705 Fixed ${fixed}/${fixable.length} patterns`));
+  } else if (fixable.length > 0 && !shouldFix) {
+    console.log(
+      chalk16.yellow(
+        `
+\u{1F4A1} Run with --fix to auto-fix ${fixable.length} patterns`
+      )
+    );
+  }
+  console.log("");
+  const unfixable = invalid.filter((r) => !r.fixable);
+  if (unfixable.length > 0 && !shouldFix) {
+    process.exit(1);
+  }
+  if (invalid.length > 0 && !shouldFix) {
+    process.exit(1);
+  }
+}
+async function validatePatternDirectory(dirPath, type, schema, verbose) {
+  const results = [];
+  try {
+    const files = await fs2.promises.readdir(dirPath);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const filePath = path2.join(dirPath, file);
+      const result = await validatePatternFile(filePath, file, type, schema, verbose);
+      results.push(result);
+      if (verbose) {
+        if (result.valid) {
+          console.log(chalk16.green(`  \u2713 ${file}`));
+        } else {
+          console.log(chalk16.red(`  \u2717 ${file}`));
+        }
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.log(
+        chalk16.yellow(`  \u26A0 Could not read ${type} directory: ${dirPath}`)
+      );
+    }
+  }
+  return results;
+}
+async function validateSingleFile(filePath, verbose) {
+  const fileName = path2.basename(filePath);
+  let type;
+  let schema;
+  if (filePath.includes("/fixes/") || filePath.includes("\\fixes\\")) {
+    type = "fix";
+    schema = FixPatternSchema;
+  } else if (filePath.includes("/blueprints/") || filePath.includes("\\blueprints\\")) {
+    type = "blueprint";
+    schema = BlueprintSchema;
+  } else if (filePath.includes("/solutions/") || filePath.includes("\\solutions\\")) {
+    type = "solution";
+    schema = SolutionPatternSchema;
+  } else {
+    try {
+      const content = await fs2.promises.readFile(filePath, "utf-8");
+      const data = JSON.parse(content);
+      if (data.trigger && data.solution) {
+        type = "fix";
+        schema = FixPatternSchema;
+      } else if (data.stack && data.structure) {
+        type = "blueprint";
+        schema = BlueprintSchema;
+      } else if (data.context && data.approach) {
+        type = "solution";
+        schema = SolutionPatternSchema;
+      } else {
+        type = "blueprint";
+        schema = BlueprintSchema;
+      }
+    } catch {
+      type = "blueprint";
+      schema = BlueprintSchema;
+    }
+  }
+  return validatePatternFile(filePath, fileName, type, schema, verbose);
+}
+async function validatePatternFile(filePath, fileName, type, schema, verbose) {
+  try {
+    const content = await fs2.promises.readFile(filePath, "utf-8");
+    const data = JSON.parse(content);
+    const validation = schema.safeParse(data);
+    if (validation.success) {
+      return {
+        file: fileName,
+        type,
+        valid: true,
+        errors: [],
+        fixable: false
+      };
+    }
+    const errors = validation.error.issues.map(
+      (i) => `${i.path.join(".")}: ${i.message}`
+    );
+    const { fixable, fixedData } = tryAutoFix(data, type, validation.error.issues);
+    return {
+      file: fileName,
+      type,
+      valid: false,
+      errors,
+      fixable,
+      fixedData
+    };
+  } catch (error) {
+    return {
+      file: fileName,
+      type,
+      valid: false,
+      errors: [
+        error instanceof Error ? error.message : "Failed to parse JSON"
+      ],
+      fixable: false
+    };
+  }
+}
+function tryAutoFix(data, type, issues) {
+  const fixedData = { ...data };
+  let allFixable = true;
+  for (const issue of issues) {
+    const pathStr = issue.path.join(".");
+    if (pathStr === "metrics" && issue.code === "invalid_type") {
+      fixedData.metrics = createDefaultMetrics();
+      continue;
+    }
+    if (pathStr === "setup" && issue.code === "invalid_type" && type === "blueprint") {
+      fixedData.setup = {
+        commands: [],
+        envVars: [],
+        dependencies: []
+      };
+      continue;
+    }
+    if (pathStr === "relatedPatterns" && issue.code === "invalid_type") {
+      fixedData.relatedPatterns = [];
+      continue;
+    }
+    if (pathStr === "tags" && issue.code === "invalid_type") {
+      fixedData.tags = [];
+      continue;
+    }
+    if (pathStr === "errorSignatures" && issue.code === "invalid_type" && type === "fix") {
+      fixedData.errorSignatures = [];
+      continue;
+    }
+    if (pathStr === "codeChanges" && issue.code === "invalid_type" && type === "fix") {
+      fixedData.codeChanges = [];
+      continue;
+    }
+    if (pathStr === "problemKeywords" && issue.code === "invalid_type" && type === "solution") {
+      fixedData.problemKeywords = [];
+      continue;
+    }
+    if (pathStr === "implementations" && issue.code === "invalid_type" && type === "solution") {
+      fixedData.implementations = [];
+      continue;
+    }
+    allFixable = false;
+  }
+  let schema;
+  if (type === "fix") {
+    schema = FixPatternSchema;
+  } else if (type === "blueprint") {
+    schema = BlueprintSchema;
+  } else {
+    schema = SolutionPatternSchema;
+  }
+  const revalidation = schema.safeParse(fixedData);
+  if (revalidation.success) {
+    return { fixable: true, fixedData };
+  }
+  if (allFixable) {
+    return { fixable: true, fixedData };
+  }
+  return { fixable: false };
+}
 
 // src/cli/commands/solution.ts
 import chalk17 from "chalk";
 import * as p12 from "@clack/prompts";
-import * as path2 from "path";
+import * as path3 from "path";
 import {
   PatternStore as PatternStore3,
   CodeAnalyzer
@@ -6444,7 +6785,7 @@ async function solutionCaptureCommand(options) {
     }
     targetPath = pathInput;
   }
-  const absolutePath = path2.isAbsolute(targetPath) ? targetPath : path2.resolve(cwd, targetPath);
+  const absolutePath = path3.isAbsolute(targetPath) ? targetPath : path3.resolve(cwd, targetPath);
   let name = options.name;
   if (!name) {
     const nameInput = await p12.text({
@@ -6736,13 +7077,13 @@ async function solutionApplyCommand(solutionId, options) {
   spinner10.start("Applying solution...");
   try {
     const outputDir = options.output || cwd;
-    const fs2 = await import("fs");
+    const fs3 = 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 fs3.promises.mkdir(dir, { recursive: true });
+      await fs3.promises.writeFile(filePath, file.content);
     }
     await store.updateSolutionMetrics(solution.id, true);
     spinner10.stop("Solution applied");
@@ -6909,6 +7250,11 @@ program.command("learn:config").description("Configure learning settings").optio
 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: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(
+  "-t, --type <type>",
+  "Pattern type to validate (fix, blueprint, solution, all)",
+  "all"
+).option("-f, --file <path>", "Validate a specific file by path").option("--fix", "Automatically fix common issues (missing metrics, setup, etc.)").option("-v, --verbose", "Show detailed validation output").action(learnValidateCommand);
 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)"