trackops 2.1.0 → 2.2.0

package/README.md

@@ -31,7 +31,7 @@ No sustituye tu producto. Ordena el trabajo que ocurre alrededor del producto:
 - define una fuente de verdad operativa dentro del repo
 - separa producto y operaciones para que no se mezclen
 - da contexto persistente a los agentes entre sesiones
-- expone estado, tareas, calidad y release desde CLI y dashboard
+- expone estado, tareas, Quality Guard, readiness y release desde CLI y dashboard
 
 Si quieres ir más allá, puedes instalar OPERA, la metodología opcional que añade discovery, contrato operativo, readiness y un equipo coordinado de especialistas.
 
@@ -152,6 +152,12 @@ trackops dashboard
 trackops quality status
 ```
 
+Si quieres una skill pública centrada en esta capa de auditoría, verificación y readiness:
+
+```bash
+npx skills add Baxahaun/trackops --skill trackops-quality-guard --agent "*" --global -y
+```
+
 Para release:
 
 ```bash
@@ -181,7 +187,7 @@ It does not replace your product. It organizes the work around the product:
 - defines an operational source of truth inside the repository
 - keeps product and operations separate
 - gives agents persistent context across sessions
-- exposes status, tasks, quality, and release state through CLI and dashboard
+- exposes status, tasks, Quality Guard, readiness, and release state through CLI and dashboard
 
 If you need a stricter operating model, you can install OPERA, the optional methodology that adds discovery, an operating contract, readiness checks, and a coordinated team of specialists.
 
@@ -302,6 +308,12 @@ trackops dashboard
 trackops quality status
 ```
 
+If you want a public skill focused on this audit, verification, and readiness layer:
+
+```bash
+npx skills add Baxahaun/trackops --skill trackops-quality-guard --agent "*" --global -y
+```
+
 For release:
 
 ```bash

package/lib/opera.js

@@ -15,7 +15,7 @@ const fmt = require("./cli-format");
 const TEMPLATES_DIR = path.join(__dirname, "..", "templates", "opera");
 const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
 const OPERA_VERSION = require("../package.json").version;
-const AUXILIARY_SKILLS = ["opera-skill", "opera-quality-guard", "project-starter-skill", "opera-contract-auditor", "opera-policy-guard"];
+const AUXILIARY_SKILLS = ["opera-skill", "trackops-quality-guard", "project-starter-skill", "opera-contract-auditor", "opera-policy-guard"];
 
 function nowIso() {
   return new Date().toISOString();

package/lib/skills.js

@@ -8,15 +8,16 @@ const { t, setLocale } = require("./i18n");
 const { resolveSkillFile } = require("./resources");
 const fmt = require("./cli-format");
 
-const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
-const INSTALLED_SKILL_PRIORITY = [
-  "opera-skill",
-  "project-starter-skill",
-  "opera-contract-auditor",
-  "opera-policy-guard",
-  "commiter",
-  "changelog-updater",
-];
+const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
+const INSTALLED_SKILL_PRIORITY = [
+  "opera-skill",
+  "project-starter-skill",
+  "trackops-quality-guard",
+  "opera-contract-auditor",
+  "opera-policy-guard",
+  "commiter",
+  "changelog-updater",
+];
 
 function copyDirRecursive(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
@@ -31,20 +32,62 @@ function copyDirRecursive(src, dest) {
   }
 }
 
-function parseFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const fm = {};
-  for (const line of match[1].split("\n")) {
-    const sep = line.indexOf(":");
-    if (sep > 0) {
-      const key = line.slice(0, sep).trim().replace(/^["']|["']$/g, "");
-      const val = line.slice(sep + 1).trim().replace(/^["']|["']$/g, "");
-      fm[key] = val;
-    }
-  }
-  return fm;
-}
+function stripFrontmatterValue(value) {
+  return String(value || "").trim().replace(/^["']|["']$/g, "");
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const lines = match[1].split("\n");
+  const root = {};
+  const stack = [{ indent: -1, container: root }];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\t/g, "  ");
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.match(/^ */)[0].length;
+
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+
+    const current = stack[stack.length - 1].container;
+    if (trimmed.startsWith("- ")) {
+      if (Array.isArray(current)) {
+        current.push(stripFrontmatterValue(trimmed.slice(2)));
+      }
+      continue;
+    }
+
+    const sep = trimmed.indexOf(":");
+    if (sep <= 0 || Array.isArray(current)) continue;
+
+    const key = stripFrontmatterValue(trimmed.slice(0, sep));
+    const rawValue = trimmed.slice(sep + 1).trim();
+    if (rawValue) {
+      current[key] = stripFrontmatterValue(rawValue);
+      continue;
+    }
+
+    let child = {};
+    for (let peekIndex = index + 1; peekIndex < lines.length; peekIndex += 1) {
+      const peekLine = lines[peekIndex].replace(/\t/g, "  ");
+      const peekTrimmed = peekLine.trim();
+      if (!peekTrimmed || peekTrimmed.startsWith("#")) continue;
+      const peekIndent = peekLine.match(/^ */)[0].length;
+      if (peekIndent <= indent) break;
+      child = peekTrimmed.startsWith("- ") ? [] : {};
+      break;
+    }
+
+    current[key] = child;
+    stack.push({ indent, container: child });
+  }
+
+  return root;
+}
 
 function getSkillsDir(root) {
   return config.ensureContext(root).paths.skillsDir;
@@ -54,29 +97,39 @@ function getRegistryPath(root) {
   return config.ensureContext(root).paths.registryPath;
 }
 
-function catalogSkills() {
-  if (!fs.existsSync(SKILLS_TEMPLATES_DIR)) return [];
-  return fs.readdirSync(SKILLS_TEMPLATES_DIR, { withFileTypes: true })
-    .filter((e) => e.isDirectory())
-    .map((e) => {
-      const skillMd = path.join(SKILLS_TEMPLATES_DIR, e.name, "SKILL.md");
-      if (!fs.existsSync(skillMd)) return null;
-      const fm = parseFrontmatter(fs.readFileSync(skillMd, "utf8"));
-      return { name: e.name, description: fm.description || "", version: fm.version || "1.0" };
-    })
-    .filter(Boolean);
-}
+function catalogSkills() {
+  if (!fs.existsSync(SKILLS_TEMPLATES_DIR)) return [];
+  return fs.readdirSync(SKILLS_TEMPLATES_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => {
+      const skillMd = path.join(SKILLS_TEMPLATES_DIR, e.name, "SKILL.md");
+      if (!fs.existsSync(skillMd)) return null;
+      const fm = parseFrontmatter(fs.readFileSync(skillMd, "utf8"));
+      return {
+        name: e.name,
+        description: fm.description || "",
+        version: fm.metadata?.version || fm.version || "1.0",
+        triggers: Array.isArray(fm.metadata?.triggers) ? fm.metadata.triggers : [],
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
 
 function installedSkills(root) {
   const skillsDir = getSkillsDir(root);
   if (!fs.existsSync(skillsDir)) return [];
   const skills = fs.readdirSync(skillsDir, { withFileTypes: true })
-    .filter((e) => e.isDirectory() && fs.existsSync(path.join(skillsDir, e.name, "SKILL.md")))
-    .map((e) => {
-      const fm = parseFrontmatter(fs.readFileSync(path.join(skillsDir, e.name, "SKILL.md"), "utf8"));
-      return { name: e.name, description: fm.description || "", version: fm.version || "1.0" };
-    })
-    .filter(Boolean);
+    .filter((e) => e.isDirectory() && fs.existsSync(path.join(skillsDir, e.name, "SKILL.md")))
+    .map((e) => {
+      const fm = parseFrontmatter(fs.readFileSync(path.join(skillsDir, e.name, "SKILL.md"), "utf8"));
+      return {
+        name: e.name,
+        description: fm.description || "",
+        version: fm.metadata?.version || fm.version || "1.0",
+      };
+    })
+    .filter(Boolean);
   skills.sort((a, b) => {
     const ai = INSTALLED_SKILL_PRIORITY.indexOf(a.name);
     const bi = INSTALLED_SKILL_PRIORITY.indexOf(b.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackops",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Local control and coordination system for AI-agent software development",
   "main": "lib/control.js",
   "bin": {
@@ -49,11 +49,11 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "postinstall": "node scripts/postinstall-locale.js",
-    "test": "node --test scripts/quality-unit-tests.js && node scripts/smoke-tests.js",
-    "test:unit": "node --test scripts/quality-unit-tests.js",
-    "test:smoke": "node scripts/smoke-tests.js",
+  "scripts": {
+    "postinstall": "node scripts/postinstall-locale.js",
+    "test": "node --test scripts/quality-unit-tests.js && node scripts/smoke-tests.js",
+    "test:unit": "node --test scripts/quality-unit-tests.js",
+    "test:smoke": "node scripts/smoke-tests.js",
     "skill:sync-version": "node scripts/sync-skill-version.js",
     "skill:validate": "node scripts/validate-skill.js",
     "skill:smoke": "node scripts/skills-marketplace-smoke.js",

package/scripts/skills-marketplace-smoke.js

@@ -1,124 +1,156 @@
-#!/usr/bin/env node
-
-const assert = require("assert");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-const ROOT = path.resolve(__dirname, "..");
-const SKILL_DIR = path.join(ROOT, "skills", "trackops");
-const SKILL_CONFIG = JSON.parse(fs.readFileSync(path.join(SKILL_DIR, "skill.json"), "utf8"));
-
-function run(command, args, cwd, envOverrides = {}) {
-  const shell = process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
-  return spawnSync(command, args, {
-    cwd,
-    encoding: "utf8",
-    env: { ...process.env, ...envOverrides },
-    shell,
-  });
-}
-
-function getNpxCommand() {
-  return process.platform === "win32" ? "npx.cmd" : "npx";
-}
-
-function ensureOk(result, context) {
-  const output = `${result.stdout || ""}\n${result.stderr || ""}`.trim();
-  assert.strictEqual(result.status, 0, output || context);
-  return output;
-}
-
-function initGitRepo(repo) {
-  ensureOk(run("git", ["init"], repo), "git init failed");
-  ensureOk(run("git", ["config", "user.email", "skills-smoke@example.com"], repo), "git config email failed");
-  ensureOk(run("git", ["config", "user.name", "Skills Smoke"], repo), "git config name failed");
-  ensureOk(run("git", ["add", "."], repo), "git add failed");
-  ensureOk(run("git", ["commit", "-m", "skills smoke fixture"], repo), "git commit failed");
-}
-
-function buildIsolatedEnv(homeRoot) {
-  const env = {
-    HOME: homeRoot,
-    USERPROFILE: homeRoot,
-    APPDATA: path.join(homeRoot, "AppData", "Roaming"),
-    LOCALAPPDATA: path.join(homeRoot, "AppData", "Local"),
-    XDG_CONFIG_HOME: path.join(homeRoot, ".config"),
-  };
-  for (const value of Object.values(env)) {
-    fs.mkdirSync(value, { recursive: true });
-  }
-  return env;
-}
-
-function findInstalledSkill(rootDir, skillName) {
-  const matches = [];
-
-  function walk(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-        continue;
-      }
-      if (entry.isFile() && entry.name === "SKILL.md" && path.basename(path.dirname(fullPath)) === skillName) {
-        matches.push(path.dirname(fullPath));
-      }
-    }
-  }
-
-  walk(rootDir);
-  return matches;
-}
-
-function main() {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "trackops-skills-smoke-"));
-  const sourceRepo = path.join(tempRoot, "source");
-  const sourceSkillDir = path.join(sourceRepo, "skills", "trackops");
-  const homeRoot = path.join(tempRoot, "home");
-
-  fs.mkdirSync(path.dirname(sourceSkillDir), { recursive: true });
-  fs.cpSync(SKILL_DIR, sourceSkillDir, { recursive: true });
-  initGitRepo(sourceRepo);
-
-  const env = buildIsolatedEnv(homeRoot);
-  const distribution = SKILL_CONFIG.distribution || {};
-  const skillName = distribution.skill || SKILL_CONFIG.name;
-
-  const listResult = run(
-    getNpxCommand(),
-    ["--yes", "skills", "add", sourceRepo, "--list", "--skill", skillName, "--full-depth", "-y"],
-    ROOT,
-    env,
-  );
-  const listOutput = ensureOk(listResult, "skills list failed");
-  assert.match(listOutput, /\btrackops\b/i, listOutput);
-
-  const installResult = run(
-    getNpxCommand(),
-    ["--yes", "skills", "add", sourceRepo, "--skill", skillName, "--full-depth", "--global", "--agent", "codex", "--copy", "-y"],
-    ROOT,
-    env,
-  );
-  ensureOk(installResult, "skills install failed");
-
-  const installed = findInstalledSkill(homeRoot, skillName);
-  assert.ok(installed.length >= 1, `trackops skill was not installed under ${homeRoot}`);
-
-  const installedSkillDir = installed[0];
-  assert.ok(fs.existsSync(path.join(installedSkillDir, "references", "activation.md")));
-  assert.ok(fs.existsSync(path.join(installedSkillDir, "skill.json")));
-  assert.ok(!fs.existsSync(path.join(installedSkillDir, "scripts", "bootstrap-trackops.js")));
-
-  fs.rmSync(tempRoot, { recursive: true, force: true });
-  console.log("skills marketplace smoke OK");
-}
-
-try {
-  main();
-} catch (error) {
-  console.error(error.message);
-  process.exit(1);
-}
+#!/usr/bin/env node
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const ROOT = path.resolve(__dirname, "..");
+const SKILLS_ROOT = path.join(ROOT, "skills");
+const REQUIRED_PUBLIC_SKILLS = ["trackops", "trackops-quality-guard"];
+
+const REQUIRED_FILES_BY_SKILL = {
+  trackops: [
+    "references/activation.md",
+    "references/workflow.md",
+    "references/troubleshooting.md",
+    "skill.json",
+  ],
+  "trackops-quality-guard": [
+    "references/commands.md",
+    "references/decision-policy.md",
+    "references/output-format.md",
+    "skill.json",
+  ],
+};
+
+function run(command, args, cwd, envOverrides = {}) {
+  const shell = process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+  return spawnSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...envOverrides },
+    shell,
+  });
+}
+
+function getNpxCommand() {
+  return process.platform === "win32" ? "npx.cmd" : "npx";
+}
+
+function ensureOk(result, context) {
+  const output = `${result.stdout || ""}\n${result.stderr || ""}`.trim();
+  assert.strictEqual(result.status, 0, output || context);
+  return output;
+}
+
+function initGitRepo(repo) {
+  ensureOk(run("git", ["init"], repo), "git init failed");
+  ensureOk(run("git", ["config", "user.email", "skills-smoke@example.com"], repo), "git config email failed");
+  ensureOk(run("git", ["config", "user.name", "Skills Smoke"], repo), "git config name failed");
+  ensureOk(run("git", ["add", "."], repo), "git add failed");
+  ensureOk(run("git", ["commit", "-m", "skills smoke fixture"], repo), "git commit failed");
+}
+
+function buildIsolatedEnv(homeRoot) {
+  const env = {
+    HOME: homeRoot,
+    USERPROFILE: homeRoot,
+    APPDATA: path.join(homeRoot, "AppData", "Roaming"),
+    LOCALAPPDATA: path.join(homeRoot, "AppData", "Local"),
+    XDG_CONFIG_HOME: path.join(homeRoot, ".config"),
+  };
+  for (const value of Object.values(env)) {
+    fs.mkdirSync(value, { recursive: true });
+  }
+  return env;
+}
+
+function findInstalledSkill(rootDir, skillName) {
+  const matches = [];
+
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name === "SKILL.md" && path.basename(path.dirname(fullPath)) === skillName) {
+        matches.push(path.dirname(fullPath));
+      }
+    }
+  }
+
+  walk(rootDir);
+  return matches;
+}
+
+function discoverPublicSkills() {
+  return fs.readdirSync(SKILLS_ROOT, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(SKILLS_ROOT, entry.name, "skill.json")))
+    .map((entry) => {
+      const dir = path.join(SKILLS_ROOT, entry.name);
+      const config = JSON.parse(fs.readFileSync(path.join(dir, "skill.json"), "utf8"));
+      return { name: entry.name, dir, config };
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function main() {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "trackops-skills-smoke-"));
+  const sourceRepo = path.join(tempRoot, "source");
+  const homeRoot = path.join(tempRoot, "home");
+
+  fs.mkdirSync(sourceRepo, { recursive: true });
+  fs.cpSync(SKILLS_ROOT, path.join(sourceRepo, "skills"), { recursive: true });
+  initGitRepo(sourceRepo);
+
+  const env = buildIsolatedEnv(homeRoot);
+  const skills = discoverPublicSkills();
+  for (const skillName of REQUIRED_PUBLIC_SKILLS) {
+    assert.ok(skills.some((entry) => entry.name === skillName), `missing public skill ${skillName}`);
+  }
+
+  for (const entry of skills) {
+    const distribution = entry.config.distribution || {};
+    const skillName = distribution.skill || entry.config.name;
+
+    const listResult = run(
+      getNpxCommand(),
+      ["--yes", "skills", "add", sourceRepo, "--list", "--skill", skillName, "--full-depth", "-y"],
+      ROOT,
+      env,
+    );
+    const listOutput = ensureOk(listResult, `skills list failed for ${skillName}`);
+    assert.ok(listOutput.includes(skillName), listOutput);
+
+    const installResult = run(
+      getNpxCommand(),
+      ["--yes", "skills", "add", sourceRepo, "--skill", skillName, "--full-depth", "--global", "--agent", "codex", "--copy", "-y"],
+      ROOT,
+      env,
+    );
+    ensureOk(installResult, `skills install failed for ${skillName}`);
+
+    const installed = findInstalledSkill(homeRoot, skillName);
+    assert.ok(installed.length >= 1, `${skillName} was not installed under ${homeRoot}`);
+
+    const installedSkillDir = installed[0];
+    for (const relativeFile of REQUIRED_FILES_BY_SKILL[skillName] || []) {
+      assert.ok(fs.existsSync(path.join(installedSkillDir, relativeFile)), `missing ${relativeFile} for ${skillName}`);
+    }
+  }
+
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+  console.log("skills marketplace smoke OK");
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/scripts/smoke-tests.js

@@ -340,13 +340,18 @@ async function main() {
   assert.ok(fs.existsSync(path.join(nonEmptyProject, "app", "package.json")));
   assert.ok(fs.existsSync(path.join(nonEmptyProject, "ops", "project_control.json")));
 
-  writeJson(path.join(splitProject, "app", "package.json"), {
-    name: "split-demo",
-    version: "1.0.0",
-    dependencies: { openai: "^4.0.0" },
-    scripts: { test: "echo ok" },
-  });
-  runNode([BIN, "opera", "install", "--locale", "en", "--non-interactive"], splitProject);
+  writeJson(path.join(splitProject, "app", "package.json"), {
+    name: "split-demo",
+    version: "1.0.0",
+    dependencies: { openai: "^4.0.0" },
+    scripts: { test: "echo ok" },
+  });
+  const skillCatalog = runNode([BIN, "skill", "catalog"], splitProject);
+  assert.match(skillCatalog, /trackops-quality-guard/);
+  assert.doesNotMatch(skillCatalog, /opera-quality-guard/);
+  runNode([BIN, "skill", "install", "trackops-quality-guard"], splitProject);
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "trackops-quality-guard", "SKILL.md")));
+  runNode([BIN, "opera", "install", "--locale", "en", "--non-interactive"], splitProject);
 
   assert.ok(fs.existsSync(path.join(splitProject, "ops", "genesis.md")));
   assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agent", "hub", "agent.md")));
@@ -367,13 +372,15 @@ async function main() {
   assert.strictEqual(operaControl.meta.opera.installed, true);
   assert.strictEqual(operaControl.meta.opera.bootstrap.mode, "agent_handoff");
   assert.strictEqual(operaControl.meta.opera.bootstrap.status, "awaiting_agent");
-  assert.ok(operaControl.meta.opera.skills.includes("opera-skill"));
-  assert.ok(operaControl.meta.opera.skills.includes("project-starter-skill"));
-  assert.ok(operaControl.meta.opera.skills.includes("opera-contract-auditor"));
-  assert.ok(operaControl.meta.opera.skills.includes("opera-policy-guard"));
-  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "SKILL.md")));
-  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "references", "phase-dod.md")));
-  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "project-starter-skill", "references", "opera-cycle.md")));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-skill"));
+  assert.ok(operaControl.meta.opera.skills.includes("trackops-quality-guard"));
+  assert.ok(operaControl.meta.opera.skills.includes("project-starter-skill"));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-contract-auditor"));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-policy-guard"));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "SKILL.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "trackops-quality-guard", "SKILL.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "references", "phase-dod.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "project-starter-skill", "references", "opera-cycle.md")));
   assert.ok(operaControl.meta.environment.requiredKeys.includes("OPENAI_API_KEY"));
   const envRootText = fs.readFileSync(path.join(splitProject, ".env"), "utf8");
   assert.match(envRootText, /OPENAI_API_KEY=/);

package/scripts/sync-skill-version.js

@@ -1,21 +1,31 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
-
-const ROOT = path.resolve(__dirname, "..");
-const PACKAGE_FILE = path.join(ROOT, "package.json");
-const SKILL_FILE = path.join(ROOT, "skills", "trackops", "skill.json");
-
-function main() {
-  const pkg = JSON.parse(fs.readFileSync(PACKAGE_FILE, "utf8"));
-  const skill = JSON.parse(fs.readFileSync(SKILL_FILE, "utf8"));
-
-  skill.skillVersion = pkg.version;
-  skill.trackopsVersion = pkg.version;
-
-  fs.writeFileSync(SKILL_FILE, `${JSON.stringify(skill, null, 2)}\n`, "utf8");
-  console.log(`Synced skills/trackops/skill.json to version ${pkg.version}.`);
-}
-
-main();
+const fs = require("fs");
+const path = require("path");
+
+const ROOT = path.resolve(__dirname, "..");
+const PACKAGE_FILE = path.join(ROOT, "package.json");
+
+function getSkillFiles() {
+  const skillsRoot = path.join(ROOT, "skills");
+  if (!fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(skillsRoot, entry.name, "skill.json"))
+    .filter((filePath) => fs.existsSync(filePath))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function main() {
+  const pkg = JSON.parse(fs.readFileSync(PACKAGE_FILE, "utf8"));
+  const skillFiles = getSkillFiles();
+  for (const skillFile of skillFiles) {
+    const skill = JSON.parse(fs.readFileSync(skillFile, "utf8"));
+    skill.skillVersion = pkg.version;
+    skill.trackopsVersion = pkg.version;
+    fs.writeFileSync(skillFile, `${JSON.stringify(skill, null, 2)}\n`, "utf8");
+    console.log(`Synced ${path.relative(ROOT, skillFile)} to version ${pkg.version}.`);
+  }
+}
+
+main();