@xenonbyte/da-vinci-workflow 0.1.25 → 0.2.1

package/lib/icon-sync.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const https = require("https");
 const os = require("os");
 const path = require("path");
+const { parseJsonText, readJsonFile, writeFileAtomic } = require("./utils");
 const {
   MATERIAL_ROUNDED,
   MATERIAL_OUTLINED,
@@ -13,6 +14,15 @@ const LUCIDE_TREE_URL = "https://api.github.com/repos/lucide-icons/lucide/git/tr
 const FEATHER_TREE_URL = "https://api.github.com/repos/feathericons/feather/git/trees/main?recursive=1";
 const PHOSPHOR_TREE_URL = "https://api.github.com/repos/phosphor-icons/core/git/trees/main?recursive=1";
 const DEFAULT_TIMEOUT_MS = 20000;
+const DEFAULT_MAX_REDIRECTS = 4;
+const DEFAULT_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+const DEFAULT_SOURCE_CONCURRENCY = 1;
+const DEFAULT_ICON_SOURCE_URLS = Object.freeze({
+  material: MATERIAL_METADATA_URL,
+  lucide: LUCIDE_TREE_URL,
+  feather: FEATHER_TREE_URL,
+  phosphor: PHOSPHOR_TREE_URL
+});
 
 function toBoolean(value) {
   if (value === true || value === false) {
@@ -57,7 +67,7 @@ function parseGoogleMaterialMetadata(raw) {
   if (objectStart < 0) {
     throw new Error("Material metadata payload is not valid JSON.");
   }
-  const parsed = JSON.parse(text.slice(objectStart));
+  const parsed = parseJsonText(text.slice(objectStart), "Google Material metadata JSON payload");
   const icons = Array.isArray(parsed.icons) ? parsed.icons : [];
   const roundedFamilyKey = "Material Icons Round";
   const outlinedFamilyKey = "Material Icons Outlined";
@@ -87,7 +97,7 @@ function parseGoogleMaterialMetadata(raw) {
 
 function parseGitHubTreeIcons(raw, options) {
   const { family, prefix, suffix } = options;
-  const parsed = JSON.parse(String(raw || ""));
+  const parsed = parseJsonText(String(raw || ""), `GitHub icon tree JSON payload for ${family}`);
   const tree = Array.isArray(parsed.tree) ? parsed.tree : [];
 
   return tree
@@ -132,14 +142,47 @@ function summarizeSourceResults(sourceResults = {}) {
   };
 }
 
+function resolveRedirectUrl(fromUrl, location) {
+  if (!location) {
+    return "";
+  }
+  try {
+    const resolved = new URL(String(location), fromUrl);
+    return resolved.protocol === "https:" ? resolved.toString() : "";
+  } catch (error) {
+    return "";
+  }
+}
+
 function fetchText(url, options = {}) {
   const timeoutMs = Number.isFinite(Number(options.timeoutMs))
     ? Number(options.timeoutMs)
     : DEFAULT_TIMEOUT_MS;
+  const maxResponseBytes = Number.isFinite(Number(options.maxResponseBytes))
+    ? Math.max(1, Number(options.maxResponseBytes))
+    : DEFAULT_MAX_RESPONSE_BYTES;
+  const maxRedirects = Number.isFinite(Number(options.maxRedirects))
+    ? Math.max(0, Number(options.maxRedirects))
+    : DEFAULT_MAX_REDIRECTS;
+  const redirectCount = Number.isFinite(Number(options._redirectCount))
+    ? Number(options._redirectCount)
+    : 0;
+  const visited = options._visited instanceof Set ? options._visited : new Set();
+  const requestImpl = typeof options.httpsGet === "function" ? options.httpsGet : https.get;
+  const requestUrl = String(url || "");
 
   return new Promise((resolve, reject) => {
-    const request = https.get(
-      url,
+    let settled = false;
+    function finish(callback, value) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      callback(value);
+    }
+
+    const request = requestImpl(
+      requestUrl,
       {
         headers: {
           "User-Agent": "da-vinci-workflow/icon-sync",
@@ -148,26 +191,85 @@ function fetchText(url, options = {}) {
       },
       (response) => {
         let data = "";
+        let receivedBytes = 0;
         response.setEncoding("utf8");
         response.on("data", (chunk) => {
+          if (settled) {
+            return;
+          }
+          receivedBytes += Buffer.byteLength(chunk, "utf8");
+          if (receivedBytes > maxResponseBytes) {
+            const error = new Error(`Response body exceeded ${maxResponseBytes} bytes for ${requestUrl}.`);
+            finish(reject, error);
+            request.destroy(error);
+            return;
+          }
           data += chunk;
         });
+        response.on("error", (error) => {
+          finish(reject, error);
+        });
         response.on("end", () => {
+          if (settled) {
+            return;
+          }
+          const statusCode = Number(response.statusCode || 0);
+          if (statusCode >= 300 && statusCode < 400) {
+            if (redirectCount >= maxRedirects) {
+              finish(
+                reject,
+                new Error(
+                  `Too many redirects while fetching ${requestUrl} (limit ${maxRedirects}).`
+                )
+              );
+              return;
+            }
+
+            const redirectUrl = resolveRedirectUrl(requestUrl, response.headers && response.headers.location);
+            if (!redirectUrl) {
+              finish(
+                reject,
+                new Error(`HTTP ${statusCode} redirect without valid location for ${requestUrl}`)
+              );
+              return;
+            }
+
+            if (visited.has(redirectUrl) || redirectUrl === requestUrl) {
+              finish(reject, new Error(`Redirect loop detected while fetching ${requestUrl}.`));
+              return;
+            }
+
+            const nextVisited = new Set(visited);
+            nextVisited.add(requestUrl);
+            finish(
+              resolve,
+              fetchText(redirectUrl, {
+                ...options,
+                _redirectCount: redirectCount + 1,
+                _visited: nextVisited
+              })
+            );
+            return;
+          }
+
           if (response.statusCode && response.statusCode >= 400) {
-            reject(new Error(`HTTP ${response.statusCode} for ${url}`));
+            finish(reject, new Error(`HTTP ${response.statusCode} for ${requestUrl}`));
             return;
           }
-          resolve(data);
+          finish(resolve, data);
         });
       }
     );
 
     request.on("error", (error) => {
-      reject(error);
+      finish(reject, error);
     });
 
     request.setTimeout(timeoutMs, () => {
-      request.destroy(new Error(`Request timeout after ${timeoutMs}ms for ${url}`));
+      if (settled) {
+        return;
+      }
+      request.destroy(new Error(`Request timeout after ${timeoutMs}ms for ${requestUrl}`));
     });
   });
 }
@@ -187,43 +289,46 @@ function resolveCatalogPath(options = {}) {
   return path.resolve(getDefaultCatalogPath(options.homeDir));
 }
 
-function loadIconCatalog(options = {}) {
-  const catalogPath = resolveCatalogPath(options);
-  if (!fs.existsSync(catalogPath)) {
-    return {
-      catalogPath,
-      catalog: null
-    };
-  }
-
-  const parsed = JSON.parse(fs.readFileSync(catalogPath, "utf8"));
-  if (!parsed || !Array.isArray(parsed.icons)) {
-    throw new Error(`Invalid icon catalog format: ${catalogPath}`);
+function normalizePositiveInt(value, fallback, minimum = 1, maximum = Number.POSITIVE_INFINITY) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
   }
+  return Math.max(minimum, Math.min(maximum, parsed));
+}
 
+function resolveSourceUrls(overrides = {}) {
   return {
-    catalogPath,
-    catalog: parsed
+    material:
+      typeof overrides.material === "string" && overrides.material.trim()
+        ? overrides.material.trim()
+        : DEFAULT_ICON_SOURCE_URLS.material,
+    lucide:
+      typeof overrides.lucide === "string" && overrides.lucide.trim()
+        ? overrides.lucide.trim()
+        : DEFAULT_ICON_SOURCE_URLS.lucide,
+    feather:
+      typeof overrides.feather === "string" && overrides.feather.trim()
+        ? overrides.feather.trim()
+        : DEFAULT_ICON_SOURCE_URLS.feather,
+    phosphor:
+      typeof overrides.phosphor === "string" && overrides.phosphor.trim()
+        ? overrides.phosphor.trim()
+        : DEFAULT_ICON_SOURCE_URLS.phosphor
   };
 }
 
-async function syncIconCatalog(options = {}) {
-  const catalogPath = resolveCatalogPath(options);
-  const timeoutMs = Number.isFinite(Number(options.timeoutMs))
-    ? Number(options.timeoutMs)
-    : DEFAULT_TIMEOUT_MS;
-  const strict = toBoolean(options.strict);
-  const fetchTextImpl = typeof options.fetchText === "function" ? options.fetchText : fetchText;
-
-  const sourceSpecs = [
+function buildSourceSpecs(options = {}) {
+  const sourceUrls = resolveSourceUrls(options.sourceUrls);
+  return [
     {
       key: "material",
-      url: MATERIAL_METADATA_URL,
+      url: sourceUrls.material,
       parse: parseGoogleMaterialMetadata
     },
     {
       key: "lucide",
-      url: LUCIDE_TREE_URL,
+      url: sourceUrls.lucide,
       parse: (raw) =>
         parseGitHubTreeIcons(raw, {
           family: "lucide",
@@ -233,7 +338,7 @@ async function syncIconCatalog(options = {}) {
     },
     {
       key: "feather",
-      url: FEATHER_TREE_URL,
+      url: sourceUrls.feather,
       parse: (raw) =>
         parseGitHubTreeIcons(raw, {
           family: "feather",
@@ -243,7 +348,7 @@ async function syncIconCatalog(options = {}) {
     },
     {
       key: "phosphor",
-      url: PHOSPHOR_TREE_URL,
+      url: sourceUrls.phosphor,
       parse: (raw) =>
         parseGitHubTreeIcons(raw, {
           family: "phosphor",
@@ -252,15 +357,83 @@ async function syncIconCatalog(options = {}) {
         })
     }
   ];
+}
+
+async function runSourcePool(items, worker, concurrency) {
+  const queue = Array.isArray(items) ? items.slice() : [];
+  if (queue.length === 0) {
+    return;
+  }
+
+  const workerCount = Math.min(
+    normalizePositiveInt(concurrency, DEFAULT_SOURCE_CONCURRENCY, 1, 8),
+    queue.length
+  );
+  let cursor = 0;
+
+  async function runWorker() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= queue.length) {
+        return;
+      }
+      await worker(queue[index], index);
+    }
+  }
+
+  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+}
+
+function loadIconCatalog(options = {}) {
+  const catalogPath = resolveCatalogPath(options);
+  if (!fs.existsSync(catalogPath)) {
+    return {
+      catalogPath,
+      catalog: null
+    };
+  }
+
+  const parsed = readJsonFile(catalogPath, `icon catalog JSON at ${catalogPath}`);
+  if (!parsed || !Array.isArray(parsed.icons)) {
+    throw new Error(`Invalid icon catalog format: ${catalogPath}`);
+  }
+
+  return {
+    catalogPath,
+    catalog: parsed
+  };
+}
+
+async function syncIconCatalog(options = {}) {
+  const catalogPath = resolveCatalogPath(options);
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs))
+    ? Number(options.timeoutMs)
+    : DEFAULT_TIMEOUT_MS;
+  const maxResponseBytes = Number.isFinite(Number(options.maxResponseBytes))
+    ? Math.max(1, Number(options.maxResponseBytes))
+    : DEFAULT_MAX_RESPONSE_BYTES;
+  const strict = toBoolean(options.strict);
+  const fetchTextImpl = typeof options.fetchText === "function" ? options.fetchText : fetchText;
+  const sourceConcurrency = normalizePositiveInt(
+    options.sourceConcurrency,
+    DEFAULT_SOURCE_CONCURRENCY,
+    1,
+    4
+  );
+
+  const sourceSpecs = buildSourceSpecs(options);
 
   const sourceResults = {};
   const collected = [];
 
-  await Promise.all(
-    sourceSpecs.map(async (spec) => {
+  await runSourcePool(
+    sourceSpecs,
+    async (spec) => {
       try {
         const raw = await fetchTextImpl(spec.url, {
-          timeoutMs
+          timeoutMs,
+          maxResponseBytes
         });
         const records = spec.parse(raw);
         sourceResults[spec.key] = {
@@ -277,7 +450,8 @@ async function syncIconCatalog(options = {}) {
           error: error.message || String(error)
         };
       }
-    })
+    },
+    sourceConcurrency
   );
 
   const icons = dedupeIconRecords(collected);
@@ -310,7 +484,7 @@ async function syncIconCatalog(options = {}) {
   };
 
   ensureDir(catalogPath);
-  fs.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2));
+  writeFileAtomic(catalogPath, JSON.stringify(catalog, null, 2));
 
   return {
     catalogPath,
@@ -349,13 +523,18 @@ module.exports = {
   LUCIDE_TREE_URL,
   FEATHER_TREE_URL,
   PHOSPHOR_TREE_URL,
+  DEFAULT_ICON_SOURCE_URLS,
   getDefaultCatalogPath,
   resolveCatalogPath,
   loadIconCatalog,
   syncIconCatalog,
   formatIconSyncReport,
+  buildSourceSpecs,
   parseGoogleMaterialMetadata,
   parseGitHubTreeIcons,
   dedupeIconRecords,
-  summarizeSourceResults
+  summarizeSourceResults,
+  fetchText,
+  resolveRedirectUrl,
+  DEFAULT_SOURCE_CONCURRENCY
 };

package/lib/install.js

@@ -19,62 +19,71 @@ const REQUIRED_FILES = [
   ...listFiles(path.join(REPO_ROOT, "examples")).map((filePath) => path.relative(REPO_ROOT, filePath))
 ];
 
-const CODEX_PROMPT_TARGETS = listFiles(path.join(REPO_ROOT, "commands", "codex", "prompts")).map(
-  (filePath) => path.join(".codex", "prompts", path.basename(filePath))
+const CODEX_PROMPT_TARGET_PAIRS = listFiles(path.join(REPO_ROOT, "commands", "codex", "prompts")).map(
+  (filePath) => ({
+    sourcePath: filePath,
+    targetPath: path.join(".codex", "prompts", path.basename(filePath))
+  })
 );
 
-const CODEX_SKILL_TARGETS = [
-  path.join(".codex", "skills", "da-vinci", "SKILL.md"),
-  ...listFiles(path.join(REPO_ROOT, "agents")).map((filePath) =>
-    path.join(".codex", "skills", "da-vinci", "agents", path.relative(path.join(REPO_ROOT, "agents"), filePath))
+const CODEX_SKILL_TARGET_PAIRS = [
+  {
+    sourcePath: path.join(REPO_ROOT, "SKILL.md"),
+    targetPath: path.join(".codex", "skills", "da-vinci", "SKILL.md")
+  },
+  ...buildTargetPairs(
+    path.join(REPO_ROOT, "agents"),
+    path.join(".codex", "skills", "da-vinci", "agents")
   ),
-  ...listFiles(path.join(REPO_ROOT, "references")).map((filePath) =>
-    path.join(
-      ".codex",
-      "skills",
-      "da-vinci",
-      "references",
-      path.relative(path.join(REPO_ROOT, "references"), filePath)
-    )
+  ...buildTargetPairs(
+    path.join(REPO_ROOT, "references"),
+    path.join(".codex", "skills", "da-vinci", "references")
   ),
-  ...listFiles(path.join(REPO_ROOT, "docs")).map((filePath) =>
-    path.join(".codex", "skills", "da-vinci", "docs", path.relative(path.join(REPO_ROOT, "docs"), filePath))
+  ...buildTargetPairs(
+    path.join(REPO_ROOT, "docs"),
+    path.join(".codex", "skills", "da-vinci", "docs")
   ),
-  ...listFiles(path.join(REPO_ROOT, "examples")).map((filePath) =>
-    path.join(
-      ".codex",
-      "skills",
-      "da-vinci",
-      "examples",
-      path.relative(path.join(REPO_ROOT, "examples"), filePath)
-    )
+  ...buildTargetPairs(
+    path.join(REPO_ROOT, "examples"),
+    path.join(".codex", "skills", "da-vinci", "examples")
   )
 ];
 
-const CLAUDE_TARGETS = [
-  path.join(".claude", "commands", "da-vinci.md"),
-  path.join(".claude", "commands", "dv", "breakdown.md"),
-  path.join(".claude", "commands", "dv", "build.md"),
-  path.join(".claude", "commands", "dv", "continue.md"),
-  path.join(".claude", "commands", "dv", "design.md"),
-  path.join(".claude", "commands", "dv", "intake.md"),
-  path.join(".claude", "commands", "dv", "prompt.md"),
-  path.join(".claude", "commands", "dv", "tasks.md"),
-  path.join(".claude", "commands", "dv", "verify.md")
+const CLAUDE_COMMAND_TARGET_PAIRS = [
+  {
+    sourcePath: path.join(REPO_ROOT, "commands", "claude", "da-vinci.md"),
+    targetPath: path.join(".claude", "commands", "da-vinci.md")
+  }
 ];
 
-const GEMINI_TARGETS = [
-  path.join(".gemini", "commands", "da-vinci.toml"),
-  path.join(".gemini", "commands", "dv", "breakdown.toml"),
-  path.join(".gemini", "commands", "dv", "build.toml"),
-  path.join(".gemini", "commands", "dv", "continue.toml"),
-  path.join(".gemini", "commands", "dv", "design.toml"),
-  path.join(".gemini", "commands", "dv", "intake.toml"),
-  path.join(".gemini", "commands", "dv", "prompt.toml"),
-  path.join(".gemini", "commands", "dv", "tasks.toml"),
-  path.join(".gemini", "commands", "dv", "verify.toml")
+const CLAUDE_ACTION_TARGET_PAIRS = buildNamedTargetPairs(
+  path.join(REPO_ROOT, "commands", "claude", "dv"),
+  path.join(".claude", "commands", "dv"),
+  ["breakdown.md", "build.md", "continue.md", "design.md", "intake.md", "prompt.md", "tasks.md", "verify.md"]
+);
+
+const GEMINI_COMMAND_TARGET_PAIRS = [
+  {
+    sourcePath: path.join(REPO_ROOT, "commands", "gemini", "da-vinci.toml"),
+    targetPath: path.join(".gemini", "commands", "da-vinci.toml")
+  }
 ];
 
+const GEMINI_ACTION_TARGET_PAIRS = buildNamedTargetPairs(
+  path.join(REPO_ROOT, "commands", "gemini", "dv"),
+  path.join(".gemini", "commands", "dv"),
+  [
+    "breakdown.toml",
+    "build.toml",
+    "continue.toml",
+    "design.toml",
+    "intake.toml",
+    "prompt.toml",
+    "tasks.toml",
+    "verify.toml"
+  ]
+);
+
 function resolveHome(homeDir) {
   return homeDir || process.env.HOME || os.homedir();
 }
@@ -156,8 +165,51 @@ function listFiles(dirPath) {
   return scan.files;
 }
 
-function getMissingTargets(homeDir, relativePaths) {
-  return relativePaths.filter((relativePath) => !fs.existsSync(path.join(homeDir, relativePath)));
+function buildTargetPairs(sourceRoot, targetRoot) {
+  return listFiles(sourceRoot).map((filePath) => ({
+    sourcePath: filePath,
+    targetPath: path.join(targetRoot, path.relative(sourceRoot, filePath))
+  }));
+}
+
+function buildNamedTargetPairs(sourceDir, targetDir, fileNames) {
+  return fileNames.map((fileName) => ({
+    sourcePath: path.join(sourceDir, fileName),
+    targetPath: path.join(targetDir, fileName)
+  }));
+}
+
+function inspectInstalledTargets(homeDir, targetPairs) {
+  const missing = [];
+  const mismatched = [];
+  const unreadable = [];
+
+  for (const pair of targetPairs) {
+    const targetPath = path.join(homeDir, pair.targetPath);
+    if (!fs.existsSync(targetPath)) {
+      missing.push(pair.targetPath);
+      continue;
+    }
+
+    try {
+      const sourceContent = fs.readFileSync(pair.sourcePath);
+      const targetContent = fs.readFileSync(targetPath);
+      if (!sourceContent.equals(targetContent)) {
+        mismatched.push(pair.targetPath);
+      }
+    } catch (error) {
+      unreadable.push(
+        `${pair.targetPath}${error && error.code ? ` (${error.code})` : error && error.message ? ` (${error.message})` : ""}`
+      );
+    }
+  }
+
+  return {
+    ok: missing.length === 0 && mismatched.length === 0 && unreadable.length === 0,
+    missing,
+    mismatched,
+    unreadable
+  };
 }
 
 function installCodex(homeDir) {
@@ -312,29 +364,45 @@ function uninstallPlatforms(platforms, options = {}) {
 
 function getStatus(options = {}) {
   const homeDir = resolveHome(options.homeDir);
-  const codexPromptMissing = getMissingTargets(homeDir, CODEX_PROMPT_TARGETS);
-  const codexSkillMissing = getMissingTargets(homeDir, CODEX_SKILL_TARGETS);
-  const claudeMissing = getMissingTargets(homeDir, CLAUDE_TARGETS);
-  const geminiMissing = getMissingTargets(homeDir, GEMINI_TARGETS);
+  const codexPrompt = inspectInstalledTargets(homeDir, CODEX_PROMPT_TARGET_PAIRS);
+  const codexSkill = inspectInstalledTargets(homeDir, CODEX_SKILL_TARGET_PAIRS);
+  const claudeCommand = inspectInstalledTargets(homeDir, CLAUDE_COMMAND_TARGET_PAIRS);
+  const claudeActionSet = inspectInstalledTargets(homeDir, CLAUDE_ACTION_TARGET_PAIRS);
+  const geminiCommand = inspectInstalledTargets(homeDir, GEMINI_COMMAND_TARGET_PAIRS);
+  const geminiActionSet = inspectInstalledTargets(homeDir, GEMINI_ACTION_TARGET_PAIRS);
 
   return {
     version: VERSION,
     homeDir,
     codex: {
-      prompt: codexPromptMissing.length === 0,
-      skill: codexSkillMissing.length === 0,
-      promptMissing: codexPromptMissing,
-      skillMissing: codexSkillMissing
+      prompt: codexPrompt.ok,
+      skill: codexSkill.ok,
+      promptMissing: codexPrompt.missing,
+      promptMismatched: codexPrompt.mismatched,
+      promptUnreadable: codexPrompt.unreadable,
+      skillMissing: codexSkill.missing,
+      skillMismatched: codexSkill.mismatched,
+      skillUnreadable: codexSkill.unreadable
     },
     claude: {
-      command: claudeMissing.length === 0,
-      actionSet: claudeMissing.length === 0,
-      missing: claudeMissing
+      command: claudeCommand.ok,
+      actionSet: claudeActionSet.ok,
+      commandMissing: claudeCommand.missing,
+      commandMismatched: claudeCommand.mismatched,
+      commandUnreadable: claudeCommand.unreadable,
+      actionSetMissing: claudeActionSet.missing,
+      actionSetMismatched: claudeActionSet.mismatched,
+      actionSetUnreadable: claudeActionSet.unreadable
     },
     gemini: {
-      command: geminiMissing.length === 0,
-      actionSet: geminiMissing.length === 0,
-      missing: geminiMissing
+      command: geminiCommand.ok,
+      actionSet: geminiActionSet.ok,
+      commandMissing: geminiCommand.missing,
+      commandMismatched: geminiCommand.mismatched,
+      commandUnreadable: geminiCommand.unreadable,
+      actionSetMissing: geminiActionSet.missing,
+      actionSetMismatched: geminiActionSet.mismatched,
+      actionSetUnreadable: geminiActionSet.unreadable
     }
   };
 }