trackops 1.0.1 → 2.0.0

package/lib/preferences.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+const config = require("./config");
+const runtimeState = require("./runtime-state");
+const { setLocale, t } = require("./i18n");
+const { normalizeLocale } = require("./locale");
+
+function formatLocaleSource(source) {
+  return t(`locale.source.${String(source || "").trim()}`) || source || t("locale.none");
+}
+
+function resolveProjectLocale(root) {
+  const context = config.resolveWorkspaceContext(root || process.cwd());
+  if (!context) return null;
+  try {
+    return config.getLocale(config.loadControl(context));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function cmdLocale(args = [], root) {
+  const sub = args[0];
+  const projectLocale = resolveProjectLocale(root);
+  const doctor = runtimeState.doctorLocale(projectLocale);
+  setLocale(doctor.effectiveLocale);
+
+  if (sub === "get" || !sub) {
+    console.log(`${t("locale.effective")}: ${doctor.effectiveLocale}`);
+    console.log(`${t("locale.source")}: ${formatLocaleSource(doctor.source)}`);
+    console.log(`${t("locale.global")}: ${doctor.globalLocale || t("locale.none")}`);
+    if (doctor.projectLocale) {
+      console.log(`${t("locale.project")}: ${doctor.projectLocale}`);
+    }
+    return;
+  }
+
+  if (sub === "set") {
+    const nextLocale = normalizeLocale(args[1]);
+    if (!nextLocale) {
+      throw new Error(t("locale.invalid", { value: String(args[1] || "") }));
+    }
+    runtimeState.writeRuntimeState({ locale: nextLocale, localeSource: "manual" });
+    setLocale(nextLocale);
+    console.log(t("locale.updated", { locale: nextLocale }));
+    return;
+  }
+
+  console.log(t("cli.usage.locale"));
+}
+
+function cmdDoctor(args = [], root) {
+  const sub = args[0];
+  if (sub !== "locale") {
+    console.log(t("cli.usage.doctor"));
+    return;
+  }
+
+  const projectLocale = resolveProjectLocale(root);
+  const doctor = runtimeState.doctorLocale(projectLocale);
+  setLocale(doctor.effectiveLocale);
+  console.log(`${t("locale.effective")}: ${doctor.effectiveLocale}`);
+  console.log(`${t("locale.source")}: ${formatLocaleSource(doctor.source)}`);
+  console.log(`${t("locale.global")}: ${doctor.globalLocale || t("locale.none")}`);
+  console.log(`${t("locale.project")}: ${doctor.projectLocale || t("locale.none")}`);
+  console.log(`${t("locale.env")}: ${doctor.envLocale || t("locale.none")}`);
+  console.log(`${t("locale.system")}: ${doctor.systemLocale}`);
+  console.log(`${t("locale.runtimeFile")}: ${doctor.runtimeFile}`);
+}
+
+module.exports = {
+  cmdLocale,
+  cmdDoctor,
+};

package/lib/registry.js

@@ -4,6 +4,7 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
+const config = require("./config");
 const { t } = require("./i18n");
 
 const REGISTRY_DIR = path.join(os.homedir(), ".codex", "trackops");
@@ -39,9 +40,11 @@ function ensureRegistryDir() {
 function loadRegistry() {
   ensureRegistryDir();
   if (!fs.existsSync(REGISTRY_FILE)) {
-    return { version: 1, updatedAt: nowIso(), projects: [] };
+    return { version: 2, updatedAt: nowIso(), projects: [] };
   }
-  return JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf8"));
+  const registry = JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf8"));
+  if (!registry.version) registry.version = 1;
+  return registry;
 }
 
 function saveRegistry(registry) {
@@ -51,19 +54,21 @@ function saveRegistry(registry) {
 }
 
 function isProjectInstalled(rootDir) {
-  return fs.existsSync(path.join(rootDir, "project_control.json"));
+  const context = config.resolveWorkspaceContext(rootDir);
+  return Boolean(context && fs.existsSync(context.controlFile));
 }
 
 function inspectProject(rootDir) {
-  const root = path.resolve(rootDir);
-  const controlStateFile = path.join(root, "project_control.json");
+  const context = config.resolveWorkspaceContext(rootDir) || config.createLegacyContext(rootDir);
+  const root = context.workspaceRoot;
+  const controlStateFile = context.controlFile;
 
   if (!fs.existsSync(controlStateFile)) {
     throw new Error(`Project '${root}' does not have trackops installed.`);
   }
 
   let packageJson = {};
-  const packageFile = path.join(root, "package.json");
+  const packageFile = context.packageFile;
   if (fs.existsSync(packageFile)) {
     packageJson = JSON.parse(fs.readFileSync(packageFile, "utf8"));
   }
@@ -76,6 +81,10 @@ function inspectProject(rootDir) {
     id: `${slugify(projectName) || "project"}-${shortHash(root)}`,
     name: projectName,
     root,
+    workspaceRoot: root,
+    appRoot: context.appRoot,
+    opsRoot: context.opsRoot,
+    layout: context.layout,
     packageName: packageJson.name || null,
     controlStateFile,
     registeredAt: nowIso(),
@@ -86,7 +95,7 @@ function inspectProject(rootDir) {
 function registerProject(rootDir) {
   const registry = loadRegistry();
   const entry = inspectProject(rootDir);
-  const existingIndex = registry.projects.findIndex((p) => p.root === entry.root);
+  const existingIndex = registry.projects.findIndex((p) => (p.workspaceRoot || p.root) === entry.workspaceRoot);
 
   if (existingIndex >= 0) {
     registry.projects[existingIndex] = {
@@ -101,13 +110,14 @@ function registerProject(rootDir) {
 
   registry.projects.sort((a, b) => a.name.localeCompare(b.name));
   saveRegistry(registry);
-  return registry.projects.find((p) => p.root === entry.root);
+  return registry.projects.find((p) => (p.workspaceRoot || p.root) === entry.workspaceRoot);
 }
 
 function unregisterProject(rootDir) {
-  const root = path.resolve(rootDir);
+  const context = config.resolveWorkspaceContext(rootDir) || config.createLegacyContext(rootDir);
+  const root = context.workspaceRoot;
   const registry = loadRegistry();
-  registry.projects = registry.projects.filter((p) => p.root !== root);
+  registry.projects = registry.projects.filter((p) => (p.workspaceRoot || p.root) !== root);
   saveRegistry(registry);
   return registry;
 }
@@ -125,7 +135,9 @@ function resolveProject(projectRef, fallbackRoot) {
 
   if (!projectRef) {
     if (fallbackRoot) {
-      return projects.find((p) => p.root === path.resolve(fallbackRoot)) || null;
+      const resolved = config.resolveWorkspaceContext(fallbackRoot);
+      const target = resolved ? resolved.workspaceRoot : path.resolve(fallbackRoot);
+      return projects.find((p) => (p.workspaceRoot || p.root) === target) || null;
     }
     return projects[0] || null;
   }
@@ -133,7 +145,7 @@ function resolveProject(projectRef, fallbackRoot) {
   const normalizedRef = path.resolve(projectRef);
   return (
     projects.find((p) => p.id === projectRef) ||
-    projects.find((p) => p.root === normalizedRef) ||
+    projects.find((p) => (p.workspaceRoot || p.root) === normalizedRef) ||
     null
   );
 }
@@ -155,7 +167,9 @@ function cmdList() {
   projects.forEach((project, index) => {
     console.log(`${index + 1}. ${project.name}`);
     console.log(`   id: ${project.id}`);
-    console.log(`   root: ${project.root}`);
+    console.log(`   root: ${project.workspaceRoot || project.root}`);
+    console.log(`   app: ${project.appRoot}`);
+    console.log(`   ops: ${project.opsRoot}`);
     console.log(`   available: ${project.available ? "yes" : "no"}`);
   });
 }

package/lib/release.js

@@ -0,0 +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 };

package/lib/resources.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const { normalizeLocale } = require("./locale");
+
+function existing(filePath) {
+  return filePath && fs.existsSync(filePath) ? filePath : null;
+}
+
+function resolveLocalizedFile(baseDir, locale, relativePath) {
+  const normalized = normalizeLocale(locale) || "es";
+  return (
+    existing(path.join(baseDir, "locales", normalized, relativePath)) ||
+    existing(path.join(baseDir, normalized, relativePath)) ||
+    existing(path.join(baseDir, relativePath)) ||
+    existing(path.join(baseDir, "locales", "es", relativePath)) ||
+    existing(path.join(baseDir, "es", relativePath))
+  );
+}
+
+function resolveLocalizedDir(baseDir, locale, relativePath = "") {
+  const normalized = normalizeLocale(locale) || "es";
+  return (
+    existing(path.join(baseDir, "locales", normalized, relativePath)) ||
+    existing(path.join(baseDir, normalized, relativePath)) ||
+    existing(path.join(baseDir, relativePath)) ||
+    existing(path.join(baseDir, "locales", "es", relativePath)) ||
+    existing(path.join(baseDir, "es", relativePath))
+  );
+}
+
+function resolveSkillFile(templatesDir, skillName, locale) {
+  return resolveLocalizedFile(path.join(templatesDir, skillName), locale, "SKILL.md");
+}
+
+module.exports = {
+  resolveLocalizedFile,
+  resolveLocalizedDir,
+  resolveSkillFile,
+};

package/lib/runtime-state.js

@@ -0,0 +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,
+};