studioflow 0.1.4 → 0.1.5

package/dist/index.js

@@ -5898,11 +5898,15 @@ import fs11 from "node:fs/promises";
 import path12 from "node:path";
 
 // src/commands/install-skills.ts
+import { createHash } from "node:crypto";
 import fs10 from "node:fs/promises";
 import path11 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
 var bundledSkillNames = ["studioflow-cli", "studioflow-investigate"];
+var skillManifestFile = "manifest.json";
+var skillMetadataFile = ".studioflow-skill.json";
+var packageName = "studioflow";
 async function pathExists(target) {
   try {
     await fs10.access(target);
@@ -5911,6 +5915,116 @@ async function pathExists(target) {
     return false;
   }
 }
+function toPosixPath(value) {
+  return value.split(path11.sep).join("/");
+}
+async function listFilesRecursively(rootDir2) {
+  const entries = await fs10.readdir(rootDir2, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const fullPath = path11.join(rootDir2, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursively(fullPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function hashDirectoryContents(rootDir2) {
+  const hasher = createHash("sha256");
+  const files = await listFilesRecursively(rootDir2);
+  for (const filePath of files) {
+    const relativePath = toPosixPath(path11.relative(rootDir2, filePath));
+    hasher.update(relativePath);
+    hasher.update("\n");
+    hasher.update(await fs10.readFile(filePath));
+    hasher.update("\n");
+  }
+  return hasher.digest("hex");
+}
+async function resolveCliPackageVersion(sourceDir) {
+  const candidates = [
+    path11.resolve(sourceDir, "../package.json"),
+    path11.resolve(__dirname2, "../../package.json"),
+    path11.resolve(process.cwd(), "apps/cli/package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = await fs10.readFile(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name === packageName && typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+function isValidManifest(value) {
+  if (!value || typeof value !== "object") return false;
+  const manifest = value;
+  if (manifest.schemaVersion !== 1 || manifest.packageName !== packageName || typeof manifest.packageVersion !== "string" || !manifest.skills || typeof manifest.skills !== "object") {
+    return false;
+  }
+  return bundledSkillNames.every((name) => {
+    const entry = manifest.skills[name];
+    return Boolean(entry && typeof entry.hash === "string" && entry.hash.length > 0);
+  });
+}
+async function resolveBundledSkillsManifest(sourceDir) {
+  const manifestPath = path11.join(sourceDir, skillManifestFile);
+  if (await pathExists(manifestPath)) {
+    try {
+      const raw = await fs10.readFile(manifestPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (isValidManifest(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const skills = {};
+  for (const skillName of bundledSkillNames) {
+    const skillPath = path11.join(sourceDir, skillName);
+    skills[skillName] = {
+      hash: await hashDirectoryContents(skillPath)
+    };
+  }
+  return {
+    schemaVersion: 1,
+    packageName,
+    packageVersion: await resolveCliPackageVersion(sourceDir),
+    skills
+  };
+}
+async function readInstalledSkillMetadata(skillDir) {
+  const metadataPath = path11.join(skillDir, skillMetadataFile);
+  if (!await pathExists(metadataPath)) {
+    return null;
+  }
+  try {
+    const raw = await fs10.readFile(metadataPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.packageName === "string" && typeof parsed.cliVersion === "string" && typeof parsed.skillHash === "string" && typeof parsed.installedAt === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function writeInstalledSkillMetadata(skillDir, expectedVersion, expectedHash) {
+  const metadata = {
+    packageName,
+    cliVersion: expectedVersion,
+    skillHash: expectedHash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs10.writeFile(path11.join(skillDir, skillMetadataFile), `${JSON.stringify(metadata, null, 2)}
+`);
+}
 async function resolveBundledSkillsDir() {
   const candidates = [
     process.env.STUDIOFLOW_SKILLS_SOURCE,
@@ -5934,28 +6048,48 @@ async function resolveBundledSkillsDir() {
     `Could not locate bundled skills. Checked: ${candidates.join(", ")}. Set STUDIOFLOW_SKILLS_SOURCE if needed.`
   );
 }
-async function syncSkillsToTarget(sourceDir, targetDir, force) {
+async function syncSkillsToTarget(sourceDir, targetDir, force, manifest) {
   await fs10.mkdir(targetDir, { recursive: true });
   const installed = [];
+  const updated = [];
   const skipped = [];
   for (const skillName of bundledSkillNames) {
     const source = path11.join(sourceDir, skillName);
     const target = path11.join(targetDir, skillName);
     const exists = await pathExists(target);
-    if (exists && !force) {
-      skipped.push(skillName);
+    const expectedHash = manifest.skills[skillName]?.hash;
+    if (!expectedHash) {
+      throw new Error(`Missing skill hash in manifest for ${skillName}.`);
+    }
+    if (!exists) {
+      await fs10.cp(source, target, { recursive: true });
+      await writeInstalledSkillMetadata(target, manifest.packageVersion, expectedHash);
+      installed.push(skillName);
       continue;
     }
-    if (exists && force) {
+    if (force) {
       await fs10.rm(target, { recursive: true, force: true });
+      await fs10.cp(source, target, { recursive: true });
+      await writeInstalledSkillMetadata(target, manifest.packageVersion, expectedHash);
+      installed.push(skillName);
+      continue;
+    }
+    const currentMetadata = await readInstalledSkillMetadata(target);
+    const matchesInstalledVersion = currentMetadata?.packageName === manifest.packageName && currentMetadata.cliVersion === manifest.packageVersion && currentMetadata.skillHash === expectedHash;
+    if (matchesInstalledVersion) {
+      skipped.push(skillName);
+      continue;
     }
+    await fs10.rm(target, { recursive: true, force: true });
     await fs10.cp(source, target, { recursive: true });
-    installed.push(skillName);
+    await writeInstalledSkillMetadata(target, manifest.packageVersion, expectedHash);
+    updated.push(skillName);
   }
-  return { installed, skipped };
+  return { installed, updated, skipped };
 }
 async function installBundledSkills(opts = {}) {
   const sourceDir = await resolveBundledSkillsDir();
+  const manifest = await resolveBundledSkillsManifest(sourceDir);
   const force = opts.force ?? false;
   const targets = [];
   if (opts.targetDir && (opts.agent || opts.codexTargetDir || opts.claudeTargetDir)) {
@@ -5980,11 +6114,12 @@ async function installBundledSkills(opts = {}) {
   }
   const results = [];
   for (const target of targets) {
-    const synced = await syncSkillsToTarget(sourceDir, target.targetDir, force);
+    const synced = await syncSkillsToTarget(sourceDir, target.targetDir, force, manifest);
     results.push({
       targetId: target.targetId,
       targetDir: target.targetDir,
       installed: synced.installed,
+      updated: synced.updated,
       skipped: synced.skipped
     });
   }
@@ -6001,8 +6136,11 @@ async function installSkillsCommand(opts = {}) {
     if (target.installed.length > 0) {
       console.log(`- Installed (${label}): ${target.installed.join(", ")}`);
     }
+    if (target.updated.length > 0) {
+      console.log(`- Updated (${label}): ${target.updated.join(", ")}`);
+    }
     if (target.skipped.length > 0) {
-      console.log(kleur_default.yellow(`- Skipped (${label}, already present): ${target.skipped.join(", ")}`));
+      console.log(kleur_default.yellow(`- Skipped (${label}, up to date): ${target.skipped.join(", ")}`));
     }
   }
   if (result.targets.some((target) => target.skipped.length > 0)) {
@@ -6049,8 +6187,11 @@ async function setupCommand(opts = {}) {
       if (target.installed.length > 0) {
         console.log(`- Installed (${label}): ${target.installed.join(", ")}`);
       }
+      if (target.updated.length > 0) {
+        console.log(`- Updated (${label}): ${target.updated.join(", ")}`);
+      }
       if (target.skipped.length > 0) {
-        console.log(kleur_default.yellow(`- Skipped (${label}, already present): ${target.skipped.join(", ")}`));
+        console.log(kleur_default.yellow(`- Skipped (${label}, up to date): ${target.skipped.join(", ")}`));
       }
     }
   }
@@ -6081,6 +6222,7 @@ async function setupCommand(opts = {}) {
         targetId: target.targetId,
         targetDir: target.targetDir,
         installed: target.installed,
+        updated: target.updated,
         skipped: target.skipped
       }))
     } : { skipped: true }