qfai 0.6.3 → 0.7.0

package/dist/cli/index.cjs

@@ -889,8 +889,8 @@ var import_promises6 = require("fs/promises");
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 async function resolveToolVersion() {
-  if ("0.6.3".length > 0) {
-    return "0.6.3";
+  if ("0.7.0".length > 0) {
+    return "0.7.0";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -3664,9 +3664,235 @@ async function writeValidationResult(root, outputPath, result) {
 `, "utf-8");
 }
 
-// src/cli/commands/validate.ts
+// src/core/sync.ts
 var import_promises19 = require("fs/promises");
 var import_node_path19 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+var import_node_url3 = require("url");
+async function exists6(target) {
+  try {
+    await (0, import_promises19.access)(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function computeFileHash(filePath) {
+  const content = await (0, import_promises19.readFile)(filePath);
+  return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex");
+}
+async function collectFilesRecursive(dir, base) {
+  const result = [];
+  if (!await exists6(dir)) {
+    return result;
+  }
+  const entries = await (0, import_promises19.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path19.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectFilesRecursive(fullPath, base);
+      result.push(...nested);
+    } else if (entry.isFile()) {
+      const relative = import_node_path19.default.relative(base, fullPath);
+      result.push(relative);
+    }
+  }
+  return result;
+}
+function resolveAssetsPath() {
+  const base = __filename;
+  const basePath = base.startsWith("file:") ? (0, import_node_url3.fileURLToPath)(base) : base;
+  return import_node_path19.default.resolve(
+    import_node_path19.default.dirname(basePath),
+    "../../assets/init/.qfai/promptpack"
+  );
+}
+async function copyDirRecursive(srcDir, destDir) {
+  await (0, import_promises19.mkdir)(destDir, { recursive: true });
+  const entries = await (0, import_promises19.readdir)(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_node_path19.default.join(srcDir, entry.name);
+    const destPath = import_node_path19.default.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await (0, import_promises19.copyFile)(srcPath, destPath);
+    }
+  }
+}
+async function createSyncData(options) {
+  const root = import_node_path19.default.resolve(options.root);
+  const version = await resolveToolVersion();
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const scope = "promptpack";
+  const assetsPromptPackPath = resolveAssetsPath();
+  const projectPromptPackPath = import_node_path19.default.join(root, ".qfai", "promptpack");
+  const diffs = [];
+  const assetsFiles = await collectFilesRecursive(
+    assetsPromptPackPath,
+    assetsPromptPackPath
+  );
+  const projectFiles = await collectFilesRecursive(
+    projectPromptPackPath,
+    projectPromptPackPath
+  );
+  const assetsSet = new Set(assetsFiles);
+  const projectSet = new Set(projectFiles);
+  for (const relativePath of assetsFiles) {
+    const assetsFilePath = import_node_path19.default.join(assetsPromptPackPath, relativePath);
+    const projectFilePath = import_node_path19.default.join(projectPromptPackPath, relativePath);
+    if (!projectSet.has(relativePath)) {
+      diffs.push({
+        filePath: relativePath,
+        status: "added",
+        reason: "File exists in assets but not in project"
+      });
+    } else {
+      const assetsHash = await computeFileHash(assetsFilePath);
+      const projectHash = await computeFileHash(projectFilePath);
+      if (assetsHash !== projectHash) {
+        diffs.push({
+          filePath: relativePath,
+          status: "changed",
+          reason: "Content differs between assets and project"
+        });
+      } else {
+        diffs.push({
+          filePath: relativePath,
+          status: "unchanged"
+        });
+      }
+    }
+  }
+  for (const relativePath of projectFiles) {
+    if (!assetsSet.has(relativePath)) {
+      diffs.push({
+        filePath: relativePath,
+        status: "removed",
+        reason: "File exists in project but not in assets (local extension)"
+      });
+    }
+  }
+  diffs.sort((a, b) => a.filePath.localeCompare(b.filePath));
+  const summary = {
+    added: diffs.filter((d) => d.status === "added").length,
+    removed: diffs.filter((d) => d.status === "removed").length,
+    changed: diffs.filter((d) => d.status === "changed").length,
+    unchanged: diffs.filter((d) => d.status === "unchanged").length
+  };
+  let exportPath;
+  if (options.mode === "export") {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const baseTimestamp = `${timestamp}-${Date.now()}`;
+    const defaultOutDir = import_node_path19.default.join(root, ".qfai", ".sync");
+    const outBase = options.outPath ? import_node_path19.default.isAbsolute(options.outPath) ? options.outPath : import_node_path19.default.resolve(root, options.outPath) : defaultOutDir;
+    let exportDir;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+      const uniqueTimestamp = attempt === 0 ? baseTimestamp : `${baseTimestamp}-${attempt}`;
+      const exportParent = import_node_path19.default.join(outBase, uniqueTimestamp);
+      const candidate = import_node_path19.default.join(exportParent, "promptpack");
+      await (0, import_promises19.mkdir)(exportParent, { recursive: true });
+      try {
+        await (0, import_promises19.mkdir)(candidate);
+        exportDir = candidate;
+        break;
+      } catch (err) {
+        const code = err?.code;
+        if (code === "EEXIST") {
+          continue;
+        }
+        throw err;
+      }
+    }
+    if (!exportDir) {
+      throw new Error("Failed to allocate unique export directory");
+    }
+    await copyDirRecursive(assetsPromptPackPath, exportDir);
+    exportPath = toRelativePath(root, exportDir);
+  }
+  return {
+    tool: "qfai",
+    version,
+    generatedAt,
+    root: toRelativePath(process.cwd(), root),
+    mode: options.mode,
+    scope,
+    summary,
+    diffs,
+    ...exportPath ? { exportPath } : {}
+  };
+}
+function computeExitCode(data) {
+  const hasDiff = data.summary.added > 0 || data.summary.removed > 0 || data.summary.changed > 0;
+  return hasDiff ? 1 : 0;
+}
+
+// src/cli/commands/sync.ts
+var import_node_path20 = __toESM(require("path"), 1);
+function formatSyncText(data) {
+  const lines = [];
+  lines.push(
+    `qfai sync: root=${data.root} mode=${data.mode} scope=${data.scope}`
+  );
+  lines.push("");
+  const diffs = data.diffs.filter((d) => d.status !== "unchanged");
+  if (diffs.length === 0) {
+    lines.push(
+      "No differences found. Project promptpack is in sync with assets."
+    );
+  } else {
+    lines.push("Differences:");
+    for (const diff of diffs) {
+      const statusMark = diff.status === "added" ? "[+]" : diff.status === "removed" ? "[-]" : "[~]";
+      lines.push(`  ${statusMark} ${diff.filePath}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    `summary: added=${data.summary.added} removed=${data.summary.removed} changed=${data.summary.changed} unchanged=${data.summary.unchanged}`
+  );
+  if (data.exportPath) {
+    lines.push("");
+    lines.push(`exported to: ${data.exportPath}`);
+    lines.push("");
+    lines.push("Next steps:");
+    const absRoot = import_node_path20.default.resolve(process.cwd(), data.root);
+    const absExportPath = import_node_path20.default.resolve(absRoot, data.exportPath);
+    lines.push(
+      `  git diff --no-index ${import_node_path20.default.join(absRoot, ".qfai", "promptpack")} ${absExportPath}`
+    );
+  } else if (data.summary.added + data.summary.changed > 0) {
+    lines.push("");
+    lines.push("To export sync candidates:");
+    lines.push("  qfai sync --mode export");
+  }
+  return lines.join("\n");
+}
+function formatSyncJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+async function runSync(options) {
+  try {
+    const data = await createSyncData({
+      root: options.root,
+      mode: options.mode,
+      ...options.outPath !== void 0 ? { outPath: options.outPath } : {}
+    });
+    const output = options.format === "json" ? formatSyncJson(data) : formatSyncText(data);
+    info(output);
+    if (options.mode === "export") {
+      return 0;
+    }
+    return computeExitCode(data);
+  } catch (err) {
+    error(`sync failed: ${err instanceof Error ? err.message : String(err)}`);
+    return 2;
+  }
+}
+
+// src/cli/commands/validate.ts
+var import_promises20 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -3681,7 +3907,7 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = import_node_path19.default.resolve(options.root);
+  const root = import_node_path21.default.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
   const normalized = normalizeValidationResult(root, result);
@@ -3798,12 +4024,12 @@ function issueKey(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await (0, import_promises19.mkdir)(import_node_path19.default.dirname(abs), { recursive: true });
-  await (0, import_promises19.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  await (0, import_promises20.mkdir)(import_node_path21.default.dirname(abs), { recursive: true });
+  await (0, import_promises20.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return import_node_path19.default.isAbsolute(jsonPath) ? jsonPath : import_node_path19.default.resolve(root, jsonPath);
+  return import_node_path21.default.isAbsolute(jsonPath) ? jsonPath : import_node_path21.default.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 
@@ -3820,6 +4046,8 @@ function parseArgs(argv, cwd) {
     reportRunValidate: false,
     doctorFormat: "text",
     validateFormat: "text",
+    syncFormat: "text",
+    syncMode: "check",
     strict: false,
     help: false
   };
@@ -3873,6 +4101,8 @@ function parseArgs(argv, cwd) {
           if (next) {
             if (command === "doctor") {
               options.doctorOut = next;
+            } else if (command === "sync") {
+              options.syncOut = next;
             } else {
               options.reportOut = next;
             }
@@ -3880,6 +4110,28 @@ function parseArgs(argv, cwd) {
         }
         i += 1;
         break;
+      case "--mode":
+        {
+          const next = args[i + 1];
+          if (!next) {
+            throw new Error(
+              '--mode option requires a value of "check" or "export"'
+            );
+          }
+          if (command !== "sync") {
+            throw new Error(
+              '--mode option is only supported for the "sync" command'
+            );
+          }
+          if (next !== "check" && next !== "export") {
+            throw new Error(
+              `Invalid value for --mode: "${next}". Expected "check" or "export".`
+            );
+          }
+          options.syncMode = next;
+        }
+        i += 1;
+        break;
       case "--in":
         {
           const next = args[i + 1];
@@ -3924,6 +4176,12 @@ function applyFormatOption(command, value, options) {
     }
     return;
   }
+  if (command === "sync") {
+    if (value === "text" || value === "json") {
+      options.syncFormat = value;
+    }
+    return;
+  }
   if (value === "md" || value === "json") {
     options.reportFormat = value;
   }
@@ -3983,6 +4241,18 @@ async function run(argv, cwd) {
         process.exitCode = exitCode;
       }
       return;
+    case "sync":
+      {
+        const resolvedRoot = await resolveRoot(options);
+        const exitCode = await runSync({
+          root: resolvedRoot,
+          mode: options.syncMode,
+          format: options.syncFormat,
+          ...options.syncOut !== void 0 ? { outPath: options.syncOut } : {}
+        });
+        process.exitCode = exitCode;
+      }
+      return;
     default:
       error(`Unknown command: ${command}`);
       info(usage());
@@ -3997,6 +4267,7 @@ Commands:
   validate   \u4ED5\u69D8/\u5951\u7D04/\u53C2\u7167\u306E\u691C\u67FB
   report     \u691C\u8A3C\u7D50\u679C\u3068\u96C6\u8A08\u3092\u51FA\u529B
   doctor     \u8A2D\u5B9A/\u30D1\u30B9/\u51FA\u529B\u524D\u63D0\u306E\u8A3A\u65AD
+  sync       PromptPack \u306E\u5DEE\u5206\u691C\u77E5\u30FB\u540C\u671F\u5019\u88DC\u66F8\u304D\u51FA\u3057
 
 Options:
   --root <path>   \u5BFE\u8C61\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA
@@ -4006,11 +4277,13 @@ Options:
   --dry-run       \u5909\u66F4\u3092\u884C\u308F\u305A\u8868\u793A\u306E\u307F
   --format <text|github>       validate \u306E\u51FA\u529B\u5F62\u5F0F
   --format <md|json>           report \u306E\u51FA\u529B\u5F62\u5F0F
-  --format <text|json>         doctor \u306E\u51FA\u529B\u5F62\u5F0F
+  --format <text|json>         doctor/sync \u306E\u51FA\u529B\u5F62\u5F0F
   --strict                     validate: warning \u4EE5\u4E0A\u3067 exit 1
   --fail-on <error|warning|never>  validate: \u5931\u6557\u6761\u4EF6
   --fail-on <error|warning>        doctor: \u5931\u6557\u6761\u4EF6
+  --mode <check|export>            sync: \u52D5\u4F5C\u30E2\u30FC\u30C9\uFF08default: check\uFF09
   --out <path>                  report/doctor: \u51FA\u529B\u5148
+  --out <dir>                   sync: export \u306E\u51FA\u529B\u5148\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\uFF08\u76F8\u5BFE/\u7D76\u5BFE\u3001export \u306E\u307F\uFF09
   --in <path>                   report: validate.json \u306E\u5165\u529B\u5148\uFF08config\u3088\u308A\u512A\u5148\uFF09
   --run-validate                report: validate \u3092\u5B9F\u884C\u3057\u3066\u304B\u3089 report \u3092\u751F\u6210
   -h, --help      \u30D8\u30EB\u30D7\u8868\u793A