trackops 2.0.4 → 2.0.5

package/lib/release.js

@@ -1,56 +1,56 @@
-#!/usr/bin/env node
-
-const { spawnSync } = require("child_process");
-const config = require("./config");
-
-function git(args, cwd) {
-  return spawnSync("git", args, { cwd, encoding: "utf8" });
-}
-
-function runGit(args, cwd, errorMessage) {
-  const result = git(args, cwd);
-  if (result.status !== 0) {
-    throw new Error(result.stderr || result.stdout || errorMessage);
-  }
-  return result.stdout.trim();
-}
-
-function parseArgs(args = []) {
-  return {
-    push: args.includes("--push"),
-  };
-}
-
-function cmdRelease(root, args = []) {
-  const context = config.ensureContext(root);
-  if (context.layout !== "split") {
-    throw new Error("trackops release requires a split workspace.");
-  }
-
-  const options = parseArgs(args);
-  const status = runGit(["status", "--porcelain"], context.workspaceRoot, "git status failed");
-  if (context.publish.requireCleanWorktree && status.trim()) {
-    throw new Error("trackops release requires a clean git worktree.");
-  }
-
-  const currentBranch = runGit(["branch", "--show-current"], context.workspaceRoot, "git branch failed");
-  if (currentBranch !== context.branches.development) {
-    throw new Error(`trackops release must run from '${context.branches.development}'.`);
-  }
-
-  const splitCommit = runGit(
-    ["subtree", "split", "--prefix", context.publish.sourceDir, context.branches.development],
-    context.workspaceRoot,
-    "git subtree split failed",
-  );
-
-  runGit(["branch", "-f", context.branches.publish, splitCommit], context.workspaceRoot, "git branch update failed");
-
-  if (options.push) {
-    runGit(["push", "origin", context.branches.publish, "--force-with-lease"], context.workspaceRoot, "git push failed");
-  }
-
-  console.log(`Release branch '${context.branches.publish}' updated from '${context.branches.development}'.`);
-}
-
-module.exports = { cmdRelease };
+#!/usr/bin/env node
+
+const { spawnSync } = require("child_process");
+const config = require("./config");
+
+function git(args, cwd) {
+  return spawnSync("git", args, { cwd, encoding: "utf8" });
+}
+
+function runGit(args, cwd, errorMessage) {
+  const result = git(args, cwd);
+  if (result.status !== 0) {
+    throw new Error(result.stderr || result.stdout || errorMessage);
+  }
+  return result.stdout.trim();
+}
+
+function parseArgs(args = []) {
+  return {
+    push: args.includes("--push"),
+  };
+}
+
+function cmdRelease(root, args = []) {
+  const context = config.ensureContext(root);
+  if (context.layout !== "split") {
+    throw new Error("trackops release requires a split workspace.");
+  }
+
+  const options = parseArgs(args);
+  const status = runGit(["status", "--porcelain"], context.workspaceRoot, "git status failed");
+  if (context.publish.requireCleanWorktree && status.trim()) {
+    throw new Error("trackops release requires a clean git worktree.");
+  }
+
+  const currentBranch = runGit(["branch", "--show-current"], context.workspaceRoot, "git branch failed");
+  if (currentBranch !== context.branches.development) {
+    throw new Error(`trackops release must run from '${context.branches.development}'.`);
+  }
+
+  const splitCommit = runGit(
+    ["subtree", "split", "--prefix", context.publish.sourceDir, context.branches.development],
+    context.workspaceRoot,
+    "git subtree split failed",
+  );
+
+  runGit(["branch", "-f", context.branches.publish, splitCommit], context.workspaceRoot, "git branch update failed");
+
+  if (options.push) {
+    runGit(["push", "origin", context.branches.publish, "--force-with-lease"], context.workspaceRoot, "git push failed");
+  }
+
+  console.log(`Release branch '${context.branches.publish}' updated from '${context.branches.development}'.`);
+}
+
+module.exports = { cmdRelease };

package/lib/runtime-state.js

@@ -1,144 +1,144 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-
-const { detectSystemLocale, isInteractive, normalizeLocale, promptForLocale } = require("./locale");
-
-function getRuntimeHome() {
-  return process.env.TRACKOPS_BOOTSTRAP_HOME || os.homedir();
-}
-
-function getRuntimeDir() {
-  return path.join(getRuntimeHome(), ".trackops");
-}
-
-function getRuntimeFile() {
-  return path.join(getRuntimeDir(), "runtime.json");
-}
-
-function defaultRuntimeState() {
-  return {
-    locale: null,
-    localeSource: null,
-    skill: null,
-    skillVersion: null,
-    runtimePackage: "trackops",
-    runtimeVersion: null,
-    bootstrapPolicy: null,
-    supportedAgentsV1: [],
-    verifiedAt: null,
-    verifiedWith: null,
-    executable: null,
-  };
-}
-
-function normalizeRuntimeState(state) {
-  const base = defaultRuntimeState();
-  const next = { ...base, ...(state || {}) };
-  next.locale = normalizeLocale(next.locale);
-  next.localeSource = next.localeSource || null;
-  next.supportedAgentsV1 = Array.isArray(next.supportedAgentsV1) ? next.supportedAgentsV1 : [];
-  return next;
-}
-
-function readRuntimeState() {
-  const file = getRuntimeFile();
-  if (!fs.existsSync(file)) return defaultRuntimeState();
-  try {
-    return normalizeRuntimeState(JSON.parse(fs.readFileSync(file, "utf8")));
-  } catch (_error) {
-    return defaultRuntimeState();
-  }
-}
-
-function writeRuntimeState(patch) {
-  const file = getRuntimeFile();
-  const state = normalizeRuntimeState({ ...readRuntimeState(), ...(patch || {}) });
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-  return state;
-}
-
-function getGlobalLocale() {
-  return readRuntimeState().locale || null;
-}
-
-function resolveLocaleState(options = {}) {
-  const runtime = readRuntimeState();
-  const explicit = normalizeLocale(options.explicitLocale);
-  if (explicit) return { locale: explicit, source: "explicit", runtime };
-
-  const project = normalizeLocale(options.projectLocale);
-  if (project) return { locale: project, source: "project", runtime };
-
-  const global = normalizeLocale(runtime.locale);
-  if (global) return { locale: global, source: "global", runtime };
-
-  const envLocale = normalizeLocale(process.env.TRACKOPS_LOCALE);
-  if (envLocale) return { locale: envLocale, source: "env", runtime };
-
-  const system = detectSystemLocale();
-  return { locale: system || "es", source: "system", runtime };
-}
-
-async function ensureGlobalLocale(options = {}) {
-  const current = readRuntimeState();
-  const explicit = normalizeLocale(options.preferredLocale);
-  if (explicit) {
-    return {
-      locale: explicit,
-      source: "explicit",
-      runtime: writeRuntimeState({ locale: explicit, localeSource: "explicit" }),
-    };
-  }
-
-  if (normalizeLocale(current.locale)) {
-    return { locale: current.locale, source: "global", runtime: current };
-  }
-
-  let locale = null;
-  let source = null;
-  if (options.interactive !== false && isInteractive()) {
-    locale = await promptForLocale(detectSystemLocale());
-    source = "prompt";
-  } else {
-    locale = detectSystemLocale() || "es";
-    source = "system";
-  }
-
-  return {
-    locale,
-    source,
-    runtime: writeRuntimeState({ locale, localeSource: source }),
-  };
-}
-
-function doctorLocale(projectLocale = null, explicitLocale = null) {
-  const resolved = resolveLocaleState({ explicitLocale, projectLocale });
-  const runtime = readRuntimeState();
-  return {
-    effectiveLocale: resolved.locale || "es",
-    source: resolved.source,
-    projectLocale: normalizeLocale(projectLocale),
-    globalLocale: normalizeLocale(runtime.locale),
-    envLocale: normalizeLocale(process.env.TRACKOPS_LOCALE),
-    systemLocale: detectSystemLocale() || "es",
-    runtimeFile: getRuntimeFile(),
-  };
-}
-
-module.exports = {
-  getRuntimeHome,
-  getRuntimeDir,
-  getRuntimeFile,
-  defaultRuntimeState,
-  normalizeRuntimeState,
-  readRuntimeState,
-  writeRuntimeState,
-  getGlobalLocale,
-  resolveLocaleState,
-  ensureGlobalLocale,
-  doctorLocale,
-};
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { detectSystemLocale, isInteractive, normalizeLocale, promptForLocale } = require("./locale");
+
+function getRuntimeHome() {
+  return process.env.TRACKOPS_BOOTSTRAP_HOME || os.homedir();
+}
+
+function getRuntimeDir() {
+  return path.join(getRuntimeHome(), ".trackops");
+}
+
+function getRuntimeFile() {
+  return path.join(getRuntimeDir(), "runtime.json");
+}
+
+function defaultRuntimeState() {
+  return {
+    locale: null,
+    localeSource: null,
+    skill: null,
+    skillVersion: null,
+    runtimePackage: "trackops",
+    runtimeVersion: null,
+    bootstrapPolicy: null,
+    supportedAgentsV1: [],
+    verifiedAt: null,
+    verifiedWith: null,
+    executable: null,
+  };
+}
+
+function normalizeRuntimeState(state) {
+  const base = defaultRuntimeState();
+  const next = { ...base, ...(state || {}) };
+  next.locale = normalizeLocale(next.locale);
+  next.localeSource = next.localeSource || null;
+  next.supportedAgentsV1 = Array.isArray(next.supportedAgentsV1) ? next.supportedAgentsV1 : [];
+  return next;
+}
+
+function readRuntimeState() {
+  const file = getRuntimeFile();
+  if (!fs.existsSync(file)) return defaultRuntimeState();
+  try {
+    return normalizeRuntimeState(JSON.parse(fs.readFileSync(file, "utf8")));
+  } catch (_error) {
+    return defaultRuntimeState();
+  }
+}
+
+function writeRuntimeState(patch) {
+  const file = getRuntimeFile();
+  const state = normalizeRuntimeState({ ...readRuntimeState(), ...(patch || {}) });
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  return state;
+}
+
+function getGlobalLocale() {
+  return readRuntimeState().locale || null;
+}
+
+function resolveLocaleState(options = {}) {
+  const runtime = readRuntimeState();
+  const explicit = normalizeLocale(options.explicitLocale);
+  if (explicit) return { locale: explicit, source: "explicit", runtime };
+
+  const project = normalizeLocale(options.projectLocale);
+  if (project) return { locale: project, source: "project", runtime };
+
+  const global = normalizeLocale(runtime.locale);
+  if (global) return { locale: global, source: "global", runtime };
+
+  const envLocale = normalizeLocale(process.env.TRACKOPS_LOCALE);
+  if (envLocale) return { locale: envLocale, source: "env", runtime };
+
+  const system = detectSystemLocale();
+  return { locale: system || "es", source: "system", runtime };
+}
+
+async function ensureGlobalLocale(options = {}) {
+  const current = readRuntimeState();
+  const explicit = normalizeLocale(options.preferredLocale);
+  if (explicit) {
+    return {
+      locale: explicit,
+      source: "explicit",
+      runtime: writeRuntimeState({ locale: explicit, localeSource: "explicit" }),
+    };
+  }
+
+  if (normalizeLocale(current.locale)) {
+    return { locale: current.locale, source: "global", runtime: current };
+  }
+
+  let locale = null;
+  let source = null;
+  if (options.interactive !== false && isInteractive()) {
+    locale = await promptForLocale(detectSystemLocale());
+    source = "prompt";
+  } else {
+    locale = detectSystemLocale() || "es";
+    source = "system";
+  }
+
+  return {
+    locale,
+    source,
+    runtime: writeRuntimeState({ locale, localeSource: source }),
+  };
+}
+
+function doctorLocale(projectLocale = null, explicitLocale = null) {
+  const resolved = resolveLocaleState({ explicitLocale, projectLocale });
+  const runtime = readRuntimeState();
+  return {
+    effectiveLocale: resolved.locale || "es",
+    source: resolved.source,
+    projectLocale: normalizeLocale(projectLocale),
+    globalLocale: normalizeLocale(runtime.locale),
+    envLocale: normalizeLocale(process.env.TRACKOPS_LOCALE),
+    systemLocale: detectSystemLocale() || "es",
+    runtimeFile: getRuntimeFile(),
+  };
+}
+
+module.exports = {
+  getRuntimeHome,
+  getRuntimeDir,
+  getRuntimeFile,
+  defaultRuntimeState,
+  normalizeRuntimeState,
+  readRuntimeState,
+  writeRuntimeState,
+  getGlobalLocale,
+  resolveLocaleState,
+  ensureGlobalLocale,
+  doctorLocale,
+};

package/lib/skills.js

@@ -8,6 +8,14 @@ const { t, setLocale } = require("./i18n");
 const { resolveSkillFile } = require("./resources");
 
 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",
+];
 
 function copyDirRecursive(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
@@ -22,9 +30,9 @@ function copyDirRecursive(src, dest) {
   }
 }
 
-function parseFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (!match) return {};
+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(":");
@@ -34,16 +42,16 @@ function parseFrontmatter(content) {
       fm[key] = val;
     }
   }
-  return fm;
-}
-
-function getSkillsDir(root) {
-  return config.ensureContext(root).paths.skillsDir;
-}
-
-function getRegistryPath(root) {
-  return config.ensureContext(root).paths.registryPath;
-}
+  return fm;
+}
+
+function getSkillsDir(root) {
+  return config.ensureContext(root).paths.skillsDir;
+}
+
+function getRegistryPath(root) {
+  return config.ensureContext(root).paths.registryPath;
+}
 
 function catalogSkills() {
   if (!fs.existsSync(SKILLS_TEMPLATES_DIR)) return [];
@@ -58,28 +66,37 @@ function catalogSkills() {
     .filter(Boolean);
 }
 
-function installedSkills(root) {
-  const skillsDir = getSkillsDir(root);
-  if (!fs.existsSync(skillsDir)) return [];
-  return 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);
-}
+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);
+  skills.sort((a, b) => {
+    const ai = INSTALLED_SKILL_PRIORITY.indexOf(a.name);
+    const bi = INSTALLED_SKILL_PRIORITY.indexOf(b.name);
+    const ap = ai >= 0 ? ai : INSTALLED_SKILL_PRIORITY.length;
+    const bp = bi >= 0 ? bi : INSTALLED_SKILL_PRIORITY.length;
+    if (ap !== bp) return ap - bp;
+    return a.name.localeCompare(b.name);
+  });
+  return skills;
+}
 
 function updateRegistry(root) {
   const registryPath = getRegistryPath(root);
   fs.mkdirSync(path.dirname(registryPath), { recursive: true });
-  let locale = "es";
-  const context = config.ensureContext(root);
-  const controlFile = config.controlFilePath(context);
-  if (fs.existsSync(controlFile)) {
-    try {
-      locale = config.getLocale(config.loadControl(context));
-      setLocale(locale);
+  let locale = "es";
+  const context = config.ensureContext(root);
+  const controlFile = config.controlFilePath(context);
+  if (fs.existsSync(controlFile)) {
+    try {
+      locale = config.getLocale(config.loadControl(context));
+      setLocale(locale);
     } catch (_error) {
       setLocale("es");
     }
@@ -97,29 +114,29 @@ function updateRegistry(root) {
   fs.writeFileSync(registryPath, lines.join("\n") + "\n", "utf8");
 
   // Also update control meta
-  if (fs.existsSync(controlFile)) {
-    try {
-      const control = config.loadControl(context);
-      if (control.meta.opera) {
-        control.meta.opera.skills = skills.map((s) => s.name);
-        config.saveControl(context, control);
-      }
+  if (fs.existsSync(controlFile)) {
+    try {
+      const control = config.loadControl(context);
+      if (control.meta.opera) {
+        control.meta.opera.skills = skills.map((s) => s.name);
+        config.saveControl(context, control);
+      }
     } catch (_e) { /* ignore */ }
   }
 }
 
-function installSkill(root, skillName) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  setLocale(config.getLocale(control));
-  const locale = config.getLocale(control);
+function installSkill(root, skillName) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  setLocale(config.getLocale(control));
+  const locale = config.getLocale(control);
 
   const templateDir = path.join(SKILLS_TEMPLATES_DIR, skillName);
   if (!fs.existsSync(templateDir)) {
     throw new Error(t("skill.notFound", { name: skillName }));
   }
 
-  const targetDir = path.join(getSkillsDir(context), skillName);
+  const targetDir = path.join(getSkillsDir(context), skillName);
   if (fs.existsSync(path.join(targetDir, "SKILL.md"))) {
     console.log(t("skill.alreadyInstalled", { name: skillName }));
     return;
@@ -130,25 +147,25 @@ function installSkill(root, skillName) {
   if (localizedSkill) {
     fs.copyFileSync(localizedSkill, path.join(targetDir, "SKILL.md"));
   }
-  updateRegistry(context);
-  console.log(t("skill.installed", { name: skillName }));
-}
-
-function removeSkill(root, skillName) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  setLocale(config.getLocale(control));
-
-  const targetDir = path.join(getSkillsDir(context), skillName);
+  updateRegistry(context);
+  console.log(t("skill.installed", { name: skillName }));
+}
+
+function removeSkill(root, skillName) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  setLocale(config.getLocale(control));
+
+  const targetDir = path.join(getSkillsDir(context), skillName);
   if (!fs.existsSync(targetDir)) {
     console.log(t("skill.notInstalled", { name: skillName }));
     return;
   }
 
   fs.rmSync(targetDir, { recursive: true, force: true });
-  updateRegistry(context);
-  console.log(t("skill.removed", { name: skillName }));
-}
+  updateRegistry(context);
+  console.log(t("skill.removed", { name: skillName }));
+}
 
 /* ── CLI commands ── */