trackops 1.0.1 → 2.0.0

package/bin/trackops.js

@@ -1,75 +1,127 @@
 #!/usr/bin/env node
-
+
 const path = require("path");
 const config = require("../lib/config");
+const runtimeState = require("../lib/runtime-state");
+const { setLocale, t } = require("../lib/i18n");
+const pkg = require("../package.json");
 
 const command = process.argv[2];
 const args = process.argv.slice(3);
 
+function initCliLocale() {
+  let projectLocale = null;
+  try {
+    const context = config.resolveWorkspaceContext();
+    if (context) {
+      projectLocale = config.getLocale(config.loadControl(context));
+    }
+  } catch (_error) {
+    projectLocale = null;
+  }
+  const doctor = runtimeState.doctorLocale(projectLocale);
+  setLocale(doctor.effectiveLocale);
+}
+
 function resolveRoot() {
-  const root = config.resolveProjectRoot();
-  if (!root) {
-    console.error("No project_control.json found in this directory or any parent.");
+  const context = config.resolveWorkspaceContext();
+  if (!context) {
+    console.error(t("cli.error.noWorkspace"));
     process.exit(1);
   }
-  return root;
+  return context.workspaceRoot;
 }
 
-function run() {
+async function run() {
+  initCliLocale();
   try {
-    switch (command) {
-      case "init":
-        require("../lib/init").cmdInit(args);
-        break;
-
-      case "status":
-        require("../lib/control").cmdStatus(resolveRoot());
-        break;
-
-      case "next":
-        require("../lib/control").cmdNext(resolveRoot());
-        break;
-
-      case "sync":
-        require("../lib/control").cmdSync(resolveRoot());
-        break;
-
-      case "dashboard":
-        require("../lib/server").run();
+    switch (command) {
+      case "init":
+        await require("../lib/init").cmdInit(args);
+        break;
+
+      case "status":
+        require("../lib/control").cmdStatus(resolveRoot());
+        break;
+
+      case "next":
+        require("../lib/control").cmdNext(resolveRoot());
+        break;
+
+      case "sync":
+        require("../lib/control").cmdSync(resolveRoot());
+        break;
+
+      case "dashboard":
+        await require("../lib/server").run(args);
+        break;
+
+      case "refresh-repo":
+        require("../lib/control").cmdRefreshRepo(resolveRoot(), args);
+        break;
+
+      case "install-hooks":
+        require("../lib/control").cmdInstallHooks(resolveRoot());
+        break;
+
+      case "task":
+        require("../lib/control").cmdTask(resolveRoot(), args);
+        break;
+
+      case "register":
+        require("../lib/registry").cmdRegister(config.resolveProjectRoot() || process.cwd());
         break;
-
-      case "refresh-repo":
-        require("../lib/control").cmdRefreshRepo(resolveRoot(), args);
+
+      case "projects":
+        require("../lib/registry").cmdList();
+        break;
+
+      case "workspace": {
+        const workspace = require("../lib/workspace");
+        const sub = args[0];
+        const root = config.resolveProjectRoot() || process.cwd();
+        if (sub === "status") workspace.cmdStatus(root);
+        else if (sub === "migrate") workspace.cmdMigrate(root, args.slice(1));
+        else console.log(t("cli.usage.workspace"));
         break;
+      }
 
-      case "install-hooks":
-        require("../lib/control").cmdInstallHooks(resolveRoot());
+      case "env": {
+        const env = require("../lib/env");
+        const sub = args[0];
+        const root = config.resolveProjectRoot() || process.cwd();
+        if (sub === "status") env.cmdStatus(root);
+        else if (sub === "sync") env.cmdSync(root);
+        else console.log(t("cli.usage.env"));
         break;
+      }
 
-      case "task":
-        require("../lib/control").cmdTask(resolveRoot(), args);
+      case "release":
+        require("../lib/release").cmdRelease(config.resolveProjectRoot() || process.cwd(), args);
         break;
 
-      case "register":
-        require("../lib/registry").cmdRegister(config.resolveProjectRoot() || process.cwd());
+      case "locale":
+        require("../lib/preferences").cmdLocale(args, config.resolveProjectRoot() || process.cwd());
         break;
 
-      case "projects":
-        require("../lib/registry").cmdList();
+      case "doctor":
+        require("../lib/preferences").cmdDoctor(args, config.resolveProjectRoot() || process.cwd());
         break;
 
       case "opera": {
         const opera = require("../lib/opera");
         const sub = args[0];
         const root = config.resolveProjectRoot() || process.cwd();
-        if (sub === "install") opera.cmdInstall(root, args.slice(1));
+        if (sub === "install") await opera.cmdInstall(root, args.slice(1));
+        else if (sub === "bootstrap") await opera.cmdBootstrap(root, args.slice(1));
+        else if (sub === "handoff") opera.cmdHandoff(root, args.slice(1));
         else if (sub === "status") opera.cmdStatus(root);
         else if (sub === "configure") opera.cmdConfigure(root, args.slice(1));
-        else if (sub === "upgrade") opera.cmdUpgrade(root);
-        else { console.log("Usage: trackops opera <install|status|configure|upgrade>"); }
+        else if (sub === "upgrade") opera.cmdUpgrade(root, args.slice(1));
+        else { console.log(t("cli.usage.opera")); }
         break;
       }
-
+
       case "skill": {
         const skills = require("../lib/skills");
         const sub = args[0];
@@ -78,10 +130,16 @@ function run() {
         else if (sub === "list") skills.cmdList(root);
         else if (sub === "remove") skills.cmdRemove(root, args[1]);
         else if (sub === "catalog") skills.cmdCatalog();
-        else { console.log("Usage: trackops skill <install|list|remove|catalog> [name]"); }
+        else { console.log(t("cli.usage.skill")); }
         break;
       }
 
+      case "version":
+      case "--version":
+      case "-v":
+        console.log(pkg.version);
+        break;
+
       case "help":
       case "--help":
       case "-h":
@@ -90,14 +148,14 @@ function run() {
         break;
 
       default:
-        console.error(`Unknown command: ${command}`);
-        console.error("Run 'trackops help' for usage.");
+        console.error(t("cli.error.unknownCommand", { command }));
+        console.error(t("cli.error.runHelp"));
         process.exit(1);
     }
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-
-run();
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+run();

package/lib/config.js

@@ -2,57 +2,263 @@
 
 const fs = require("fs");
 const path = require("path");
+const { normalizeLocale } = require("./locale");
 
-const DEFAULT_PHASES = [
-  { id: "O", label: "Orquestar", index: 1 },
-  { id: "P", label: "Probar", index: 2 },
-  { id: "E", label: "Estructurar", index: 3 },
-  { id: "R", label: "Refinar", index: 4 },
-  { id: "A", label: "Automatizar", index: 5 },
-];
+const DEFAULT_PHASE_IDS = ["O", "P", "E", "R", "A"];
+const DEFAULT_PHASE_LABELS = {
+  es: {
+    O: "Orquestar",
+    P: "Probar",
+    E: "Estructurar",
+    R: "Refinar",
+    A: "Automatizar",
+  },
+  en: {
+    O: "Orchestrate",
+    P: "Prove",
+    E: "Establish",
+    R: "Refine",
+    A: "Automate",
+  },
+};
 
 const DEFAULT_LOCALE = "es";
+const WORKSPACE_MANIFEST = ".trackops-workspace.json";
+const DEFAULT_APP_DIR = "app";
+const DEFAULT_OPS_DIR = "ops";
+const DEFAULT_DEV_BRANCH = "develop";
+const DEFAULT_PUBLISH_BRANCH = "master";
 
-function resolveProjectRoot(startDir) {
+function buildDefaultPhases(locale) {
+  const normalized = normalizeLocale(locale) || DEFAULT_LOCALE;
+  const labels = DEFAULT_PHASE_LABELS[normalized] || DEFAULT_PHASE_LABELS[DEFAULT_LOCALE];
+  return DEFAULT_PHASE_IDS.map((id, index) => ({
+    id,
+    label: labels[id],
+    index: index + 1,
+  }));
+}
+
+const DEFAULT_PHASES = buildDefaultPhases(DEFAULT_LOCALE);
+
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch (_error) {
+    return false;
+  }
+}
+
+function readJson(filePath, fallback = null) {
+  if (!fileExists(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+function createSplitContext(workspaceRoot, manifest = {}) {
+  const appDir = manifest.appDir || DEFAULT_APP_DIR;
+  const opsDir = manifest.opsDir || DEFAULT_OPS_DIR;
+  const workspace = path.resolve(workspaceRoot);
+  const appRoot = path.join(workspace, appDir);
+  const opsRoot = path.join(workspace, opsDir);
+  const env = manifest.env || {};
+
+  return {
+    layout: "split",
+    workspaceRoot: workspace,
+    root: workspace,
+    projectRoot: workspace,
+    appRoot,
+    opsRoot,
+    manifestFile: path.join(workspace, WORKSPACE_MANIFEST),
+    packageFile: path.join(appRoot, "package.json"),
+    controlFile: path.join(opsRoot, "project_control.json"),
+    runtimeFile: path.join(opsRoot, ".tmp", "project-control-runtime.json"),
+    docs: {
+      taskPlan: path.join(opsRoot, "task_plan.md"),
+      progress: path.join(opsRoot, "progress.md"),
+      findings: path.join(opsRoot, "findings.md"),
+    },
+    paths: {
+      taskPlan: path.join(opsRoot, "task_plan.md"),
+      progress: path.join(opsRoot, "progress.md"),
+      findings: path.join(opsRoot, "findings.md"),
+      architectureDir: path.join(opsRoot, "architecture"),
+      hooksDir: path.join(opsRoot, ".githooks"),
+      tmpDir: path.join(opsRoot, ".tmp"),
+      bootstrapDir: path.join(opsRoot, "bootstrap"),
+      contractDir: path.join(opsRoot, "contract"),
+      contractFile: path.join(opsRoot, "contract", "operating-contract.json"),
+      policyDir: path.join(opsRoot, "policy"),
+      autonomyPolicyFile: path.join(opsRoot, "policy", "autonomy.json"),
+      reviewsDir: path.join(opsRoot, "reviews"),
+      skillsDir: path.join(opsRoot, ".agents", "skills"),
+      registryPath: path.join(opsRoot, ".agents", "skills", "_registry.md"),
+      agentHubDir: path.join(opsRoot, ".agent", "hub"),
+      genesisFile: path.join(opsRoot, "genesis.md"),
+    },
+    env: {
+      rootFile: path.join(workspace, env.rootFile || ".env"),
+      exampleFile: path.join(workspace, env.exampleFile || ".env.example"),
+      appBridgeFile: path.join(workspace, env.appBridgeFile || path.join(appDir, ".env")),
+      appExampleBridgeFile: path.join(appRoot, ".env.example"),
+      bridgeMode: env.bridgeMode || "symlink-or-copy",
+    },
+    branches: {
+      development: manifest.branches?.development || DEFAULT_DEV_BRANCH,
+      publish: manifest.branches?.publish || DEFAULT_PUBLISH_BRANCH,
+    },
+    publish: {
+      mode: manifest.publish?.mode || "subtree-flatten",
+      sourceDir: manifest.publish?.sourceDir || appDir,
+      includeRootFiles: Array.isArray(manifest.publish?.includeRootFiles)
+        ? manifest.publish.includeRootFiles
+        : [".env.example"],
+      requireCleanWorktree: manifest.publish?.requireCleanWorktree !== false,
+    },
+  };
+}
+
+function createLegacyContext(rootDir) {
+  const root = path.resolve(rootDir);
+  return {
+    layout: "legacy",
+    workspaceRoot: root,
+    root,
+    projectRoot: root,
+    appRoot: root,
+    opsRoot: root,
+    manifestFile: null,
+    packageFile: path.join(root, "package.json"),
+    controlFile: path.join(root, "project_control.json"),
+    runtimeFile: path.join(root, ".tmp", "project-control-runtime.json"),
+    docs: {
+      taskPlan: path.join(root, "task_plan.md"),
+      progress: path.join(root, "progress.md"),
+      findings: path.join(root, "findings.md"),
+    },
+    paths: {
+      taskPlan: path.join(root, "task_plan.md"),
+      progress: path.join(root, "progress.md"),
+      findings: path.join(root, "findings.md"),
+      architectureDir: path.join(root, "architecture"),
+      hooksDir: path.join(root, ".githooks"),
+      tmpDir: path.join(root, ".tmp"),
+      bootstrapDir: path.join(root, "bootstrap"),
+      contractDir: path.join(root, "contract"),
+      contractFile: path.join(root, "contract", "operating-contract.json"),
+      policyDir: path.join(root, "policy"),
+      autonomyPolicyFile: path.join(root, "policy", "autonomy.json"),
+      reviewsDir: path.join(root, "reviews"),
+      skillsDir: path.join(root, ".agents", "skills"),
+      registryPath: path.join(root, ".agents", "skills", "_registry.md"),
+      agentHubDir: path.join(root, ".agent", "hub"),
+      genesisFile: path.join(root, "genesis.md"),
+    },
+    env: {
+      rootFile: path.join(root, ".env"),
+      exampleFile: path.join(root, ".env.example"),
+      appBridgeFile: path.join(root, ".env"),
+      appExampleBridgeFile: path.join(root, ".env.example"),
+      bridgeMode: "none",
+    },
+    branches: {
+      development: DEFAULT_DEV_BRANCH,
+      publish: DEFAULT_PUBLISH_BRANCH,
+    },
+    publish: {
+      mode: "legacy",
+      sourceDir: ".",
+      includeRootFiles: [".env.example"],
+      requireCleanWorktree: true,
+    },
+  };
+}
+
+function resolveWorkspaceContext(startDir) {
   let dir = path.resolve(startDir || process.cwd());
   const root = path.parse(dir).root;
-  while (dir !== root) {
-    if (fs.existsSync(path.join(dir, "project_control.json"))) {
-      return dir;
+  let legacyCandidate = null;
+
+  while (true) {
+    const manifestFile = path.join(dir, WORKSPACE_MANIFEST);
+    if (fileExists(manifestFile)) {
+      return createSplitContext(dir, readJson(manifestFile, {}) || {});
     }
+
+    if (!legacyCandidate && fileExists(path.join(dir, "project_control.json"))) {
+      legacyCandidate = dir;
+    }
+
+    if (dir === root) break;
     dir = path.dirname(dir);
   }
+
+  if (legacyCandidate) {
+    return createLegacyContext(legacyCandidate);
+  }
+
   return null;
 }
 
-function controlFilePath(root) {
-  return path.join(root, "project_control.json");
+function ensureContext(contextOrRoot) {
+  if (!contextOrRoot) return resolveWorkspaceContext(process.cwd());
+  if (typeof contextOrRoot === "object" && contextOrRoot.workspaceRoot) return contextOrRoot;
+  const resolved = resolveWorkspaceContext(contextOrRoot);
+  if (resolved) return resolved;
+  return createLegacyContext(contextOrRoot);
 }
 
-function runtimeFilePath(root) {
-  return path.join(root, ".tmp", "project-control-runtime.json");
+function resolveProjectRoot(startDir) {
+  const context = resolveWorkspaceContext(startDir);
+  return context ? context.workspaceRoot : null;
 }
 
-function docFilePaths(root) {
-  return {
-    taskPlan: path.join(root, "task_plan.md"),
-    progress: path.join(root, "progress.md"),
-    findings: path.join(root, "findings.md"),
-  };
+function controlFilePath(contextOrRoot) {
+  return ensureContext(contextOrRoot).controlFile;
+}
+
+function runtimeFilePath(contextOrRoot) {
+  return ensureContext(contextOrRoot).runtimeFile;
+}
+
+function docFilePaths(contextOrRoot) {
+  return ensureContext(contextOrRoot).docs;
+}
+
+function envFilePaths(contextOrRoot) {
+  return ensureContext(contextOrRoot).env;
 }
 
-function getPhases(control) {
-  if (
-    Array.isArray(control.meta?.phases) &&
-    control.meta.phases.length > 0
-  ) {
+function packageFilePath(contextOrRoot) {
+  return ensureContext(contextOrRoot).packageFile;
+}
+
+function workspaceManifestPath(contextOrRoot) {
+  return ensureContext(contextOrRoot).manifestFile;
+}
+
+function isDefaultPhaseShape(phases) {
+  if (!Array.isArray(phases) || phases.length !== DEFAULT_PHASE_IDS.length) return false;
+  return phases.every((phase, index) => phase?.id === DEFAULT_PHASE_IDS[index]);
+}
+
+function getPhases(control, localeOverride) {
+  const locale = normalizeLocale(localeOverride || control.meta?.locale) || DEFAULT_LOCALE;
+  if (Array.isArray(control.meta?.phases) && control.meta.phases.length > 0) {
+    if (isDefaultPhaseShape(control.meta.phases)) {
+      return buildDefaultPhases(locale);
+    }
     return control.meta.phases;
   }
-  return DEFAULT_PHASES;
+  return buildDefaultPhases(locale);
 }
 
 function getLocale(control) {
-  return control.meta?.locale || DEFAULT_LOCALE;
+  return normalizeLocale(control.meta?.locale) || DEFAULT_LOCALE;
 }
 
 function isOperaInstalled(control) {
@@ -63,35 +269,58 @@ function getOperaVersion(control) {
   return control.meta?.opera?.version || null;
 }
 
-// Backwards-compat aliases
-function isEtapaInstalled(control) { return isOperaInstalled(control); }
-function getEtapaVersion(control) { return getOperaVersion(control); }
-
-function loadControl(root) {
-  const filePath = controlFilePath(root);
+function loadControl(contextOrRoot) {
+  const filePath = controlFilePath(contextOrRoot);
   return JSON.parse(fs.readFileSync(filePath, "utf8"));
 }
 
-function saveControl(root, control) {
+function saveControl(contextOrRoot, control) {
   control.meta = control.meta || {};
   control.meta.updatedAt = new Date().toISOString();
-  const filePath = controlFilePath(root);
+  const filePath = controlFilePath(contextOrRoot);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(control, null, 2) + "\n", "utf8");
 }
 
+function loadWorkspaceManifest(contextOrRoot) {
+  const context = ensureContext(contextOrRoot);
+  if (!context.manifestFile || !fileExists(context.manifestFile)) return null;
+  return readJson(context.manifestFile, null);
+}
+
+function saveWorkspaceManifest(contextOrRoot, manifest) {
+  const context = ensureContext(contextOrRoot);
+  const manifestFile = context.manifestFile || path.join(context.workspaceRoot, WORKSPACE_MANIFEST);
+  fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+
 module.exports = {
   DEFAULT_PHASES,
+  DEFAULT_PHASE_IDS,
   DEFAULT_LOCALE,
+  DEFAULT_APP_DIR,
+  DEFAULT_OPS_DIR,
+  DEFAULT_DEV_BRANCH,
+  DEFAULT_PUBLISH_BRANCH,
+  WORKSPACE_MANIFEST,
+  buildDefaultPhases,
+  createSplitContext,
+  createLegacyContext,
+  resolveWorkspaceContext,
   resolveProjectRoot,
+  ensureContext,
   controlFilePath,
   runtimeFilePath,
   docFilePaths,
+  envFilePaths,
+  packageFilePath,
+  workspaceManifestPath,
+  loadWorkspaceManifest,
+  saveWorkspaceManifest,
   getPhases,
   getLocale,
   isOperaInstalled,
   getOperaVersion,
-  isEtapaInstalled,
-  getEtapaVersion,
   loadControl,
   saveControl,
 };