qfai 0.6.2 → 0.7.0

package/dist/cli/index.mjs

@@ -870,8 +870,8 @@ import { readFile as readFile3 } from "fs/promises";
 import path6 from "path";
 import { fileURLToPath } from "url";
 async function resolveToolVersion() {
-  if ("0.6.2".length > 0) {
-    return "0.6.2";
+  if ("0.7.0".length > 0) {
+    return "0.7.0";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -3645,9 +3645,235 @@ async function writeValidationResult(root, outputPath, result) {
 `, "utf-8");
 }
 
-// src/cli/commands/validate.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+// src/core/sync.ts
+import { access as access6, mkdir as mkdir4, readdir as readdir4, readFile as readFile13, copyFile as copyFile2 } from "fs/promises";
 import path19 from "path";
+import { createHash } from "crypto";
+import { fileURLToPath as fileURLToPath3 } from "url";
+async function exists6(target) {
+  try {
+    await access6(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function computeFileHash(filePath) {
+  const content = await readFile13(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+async function collectFilesRecursive(dir, base) {
+  const result = [];
+  if (!await exists6(dir)) {
+    return result;
+  }
+  const entries = await readdir4(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path19.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectFilesRecursive(fullPath, base);
+      result.push(...nested);
+    } else if (entry.isFile()) {
+      const relative = path19.relative(base, fullPath);
+      result.push(relative);
+    }
+  }
+  return result;
+}
+function resolveAssetsPath() {
+  const base = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath3(base) : base;
+  return path19.resolve(
+    path19.dirname(basePath),
+    "../../assets/init/.qfai/promptpack"
+  );
+}
+async function copyDirRecursive(srcDir, destDir) {
+  await mkdir4(destDir, { recursive: true });
+  const entries = await readdir4(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path19.join(srcDir, entry.name);
+    const destPath = path19.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await copyFile2(srcPath, destPath);
+    }
+  }
+}
+async function createSyncData(options) {
+  const root = path19.resolve(options.root);
+  const version = await resolveToolVersion();
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const scope = "promptpack";
+  const assetsPromptPackPath = resolveAssetsPath();
+  const projectPromptPackPath = path19.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 = path19.join(assetsPromptPackPath, relativePath);
+    const projectFilePath = path19.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 = path19.join(root, ".qfai", ".sync");
+    const outBase = options.outPath ? path19.isAbsolute(options.outPath) ? options.outPath : path19.resolve(root, options.outPath) : defaultOutDir;
+    let exportDir;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+      const uniqueTimestamp = attempt === 0 ? baseTimestamp : `${baseTimestamp}-${attempt}`;
+      const exportParent = path19.join(outBase, uniqueTimestamp);
+      const candidate = path19.join(exportParent, "promptpack");
+      await mkdir4(exportParent, { recursive: true });
+      try {
+        await mkdir4(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
+import path20 from "path";
+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 = path20.resolve(process.cwd(), data.root);
+    const absExportPath = path20.resolve(absRoot, data.exportPath);
+    lines.push(
+      `  git diff --no-index ${path20.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
+import { mkdir as mkdir5, writeFile as writeFile3 } from "fs/promises";
+import path21 from "path";
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -3662,7 +3888,7 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = path19.resolve(options.root);
+  const root = path21.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
   const normalized = normalizeValidationResult(root, result);
@@ -3779,12 +4005,12 @@ function issueKey(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir4(path19.dirname(abs), { recursive: true });
+  await mkdir5(path21.dirname(abs), { recursive: true });
   await writeFile3(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path19.isAbsolute(jsonPath) ? jsonPath : path19.resolve(root, jsonPath);
+  return path21.isAbsolute(jsonPath) ? jsonPath : path21.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 
@@ -3801,6 +4027,8 @@ function parseArgs(argv, cwd) {
     reportRunValidate: false,
     doctorFormat: "text",
     validateFormat: "text",
+    syncFormat: "text",
+    syncMode: "check",
     strict: false,
     help: false
   };
@@ -3854,6 +4082,8 @@ function parseArgs(argv, cwd) {
           if (next) {
             if (command === "doctor") {
               options.doctorOut = next;
+            } else if (command === "sync") {
+              options.syncOut = next;
             } else {
               options.reportOut = next;
             }
@@ -3861,6 +4091,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];
@@ -3905,6 +4157,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;
   }
@@ -3964,6 +4222,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());
@@ -3978,6 +4248,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
@@ -3987,11 +4258,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