trackops 2.0.5 → 2.1.0

package/lib/env.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
-const config = require("./config");
+const fs = require("fs");
+const path = require("path");
+const config = require("./config");
+const { t, setLocale } = require("./i18n");
 
 const SERVICE_ENV_KEYS = {
   OpenAI: ["OPENAI_API_KEY"],
@@ -184,7 +185,7 @@ function syncEnvironment(contextOrRoot, controlState, options = {}) {
   return auditEnvironment(context, control);
 }
 
-function auditEnvironment(contextOrRoot, controlState) {
+function auditEnvironment(contextOrRoot, controlState) {
   const context = config.ensureContext(contextOrRoot);
   const control = controlState || config.loadControl(context);
   const envMeta = normalizeEnvironmentMeta(control, context);
@@ -206,30 +207,41 @@ function auditEnvironment(contextOrRoot, controlState) {
     presentKeys,
     missingKeys,
     lastAuditAt: envMeta.lastAuditAt,
-  };
-}
-
-function cmdStatus(contextOrRoot) {
-  const audit = auditEnvironment(contextOrRoot);
-  console.log("Environment:");
-  console.log(`  Root .env: ${audit.files.rootEnv}`);
-  console.log(`  Example: ${audit.files.rootExample}`);
-  console.log(`  App bridge: ${audit.files.appBridge}`);
-  console.log(`  Bridge mode: ${audit.bridgeMode}`);
-  console.log(`  Required keys: ${audit.requiredKeys.length ? audit.requiredKeys.join(", ") : "none"}`);
-  console.log(`  Present: ${audit.presentKeys.length ? audit.presentKeys.join(", ") : "none"}`);
-  console.log(`  Missing: ${audit.missingKeys.length ? audit.missingKeys.join(", ") : "none"}`);
-}
-
-function cmdSync(contextOrRoot) {
-  const context = config.ensureContext(contextOrRoot);
-  const control = config.loadControl(context);
-  const audit = syncEnvironment(context, control);
-  console.log(`Environment synced at ${path.relative(context.workspaceRoot, context.env.rootFile)}`);
-  if (audit.missingKeys.length) {
-    console.log(`Missing required keys: ${audit.missingKeys.join(", ")}`);
-  }
-}
+  };
+}
+
+function initLocale(contextOrRoot) {
+  try {
+    const control = config.loadControl(config.ensureContext(contextOrRoot));
+    setLocale(config.getLocale(control));
+  } catch (_error) {
+    setLocale("es");
+  }
+}
+
+function cmdStatus(contextOrRoot) {
+  initLocale(contextOrRoot);
+  const audit = auditEnvironment(contextOrRoot);
+  console.log(t("env.status.title"));
+  console.log(t("env.status.rootEnv", { path: audit.files.rootEnv }));
+  console.log(t("env.status.example", { path: audit.files.rootExample }));
+  console.log(t("env.status.appBridge", { path: audit.files.appBridge }));
+  console.log(t("env.status.bridgeMode", { value: audit.bridgeMode }));
+  console.log(t("env.status.required", { value: audit.requiredKeys.length ? audit.requiredKeys.join(", ") : t("locale.none") }));
+  console.log(t("env.status.present", { value: audit.presentKeys.length ? audit.presentKeys.join(", ") : t("locale.none") }));
+  console.log(t("env.status.missing", { value: audit.missingKeys.length ? audit.missingKeys.join(", ") : t("locale.none") }));
+}
+
+function cmdSync(contextOrRoot) {
+  initLocale(contextOrRoot);
+  const context = config.ensureContext(contextOrRoot);
+  const control = config.loadControl(context);
+  const audit = syncEnvironment(context, control);
+  console.log(t("env.sync.updated", { path: path.relative(context.workspaceRoot, context.env.rootFile) }));
+  if (audit.missingKeys.length) {
+    console.log(t("env.sync.missing", { value: audit.missingKeys.join(", ") }));
+  }
+}
 
 module.exports = {
   SERVICE_ENV_KEYS,

package/lib/i18n.js

@@ -38,10 +38,11 @@ function getLocale() {
 
 function t(key, params) {
   ensureLoaded();
-  let message =
-    currentMessages[key] ||
-    (fallbackMessages && fallbackMessages[key]) ||
-    key;
+  const found = currentMessages[key] || (fallbackMessages && fallbackMessages[key]);
+  let message = found || key;
+  if (!found && process.env.NODE_ENV !== "production" && process.env.TRACKOPS_DEBUG) {
+    process.stderr.write(`[i18n] Missing key: ${key}\n`);
+  }
   if (params) {
     message = message.replace(/\{(\w+)\}/g, (match, paramKey) =>
       params[paramKey] !== undefined ? String(params[paramKey]) : match

package/lib/init.js

@@ -12,15 +12,36 @@ const { t, setLocale } = require("./i18n");
 const { detectSystemLocale, promptForLocale, maybePromptForLocale, resolveLocale } = require("./locale");
 const runtimeState = require("./runtime-state");
 
-const GENERATED_SCRIPT_COMMANDS = {
+const GENERATED_SCRIPT_COMMANDS = {
   ops: "npx --yes trackops",
   "ops:help": "npx --yes trackops help",
   "ops:dashboard": "npx --yes trackops dashboard",
   "ops:status": "npx --yes trackops status",
   "ops:next": "npx --yes trackops next",
   "ops:sync": "npx --yes trackops sync",
-  "ops:repo": "npx --yes trackops refresh-repo",
-};
+  "ops:repo": "npx --yes trackops refresh-repo",
+};
+
+const ROOT_PRESERVED_ENTRIES = new Set([
+  ".git",
+  ".gitignore",
+  ".gitattributes",
+  ".gitmodules",
+  ".editorconfig",
+  ".env",
+  ".env.example",
+  ".vscode",
+  ".idea",
+  ".nvmrc",
+  ".node-version",
+  ".tool-versions",
+  ".npmrc",
+  ".yarnrc.yml",
+  ".pnp.cjs",
+  ".pnp.loader.mjs",
+  "pnpm-workspace.yaml",
+  "turbo.json",
+]);
 
 function nowIso() {
   return new Date().toISOString();
@@ -81,7 +102,7 @@ function buildDefaultControl(context, options) {
   return {
     meta: {
       projectName: options.name || "My Project",
-      controlVersion: 2,
+      controlVersion: config.DEFAULT_CONTROL_VERSION,
       locale,
       phases,
       updatedAt: nowIso(),
@@ -112,12 +133,31 @@ function buildDefaultControl(context, options) {
         explanationMode: null,
         capturedAt: null,
       },
-      discovery: {
-        projectState: null,
-        documentationState: null,
-        availableArtifacts: [],
-      },
-    },
+      discovery: {
+        projectState: null,
+        documentationState: null,
+        availableArtifacts: [],
+      },
+      quality: {
+        baselineProfile: "baseline",
+        activeProfiles: [],
+        verification: {
+          testCommands: [],
+          buildCommands: [],
+          smokeCommands: [],
+          reviewRequired: false,
+        },
+        lastReportAt: null,
+        lastVerificationAt: null,
+        lastReleaseReadiness: null,
+        lastPromotionReadiness: null,
+      },
+      agentInbox: {
+        pending: [],
+        history: [],
+        lastIssuedAt: null,
+      },
+    },
     checks: {
       lastBuild: { status: "pending", date: null, note: "" },
       lastTest: { status: "pending", date: null, note: "" },
@@ -132,19 +172,30 @@ function buildDefaultControl(context, options) {
     milestones: [],
     decisionsPending: [],
     tasks: [
-      {
-        id: "ops-bootstrap",
-        title: t("init.defaultTaskTitle"),
+      {
+        id: "ops-bootstrap",
+        title: t("init.defaultTaskTitle"),
         phase: phases[0]?.id || "O",
         stream: "Operations",
         priority: "P0",
         status: "pending",
         required: true,
         dependsOn: [],
-        summary: t("init.defaultTaskSummary"),
-        acceptance: [],
-        history: [{ at: nowIso(), action: "create", note: "trackops init" }],
-      },
+        summary: t("init.defaultTaskSummary"),
+        acceptance: [],
+        execution: {
+          owner: config.DEFAULT_EXECUTION_OWNER,
+          lastActor: "system",
+          lastSource: "trackops_init",
+          currentSessionId: null,
+          lastSessionId: null,
+          lastSessionStatus: null,
+          awaitingUserConfirmation: false,
+          verificationPending: false,
+          updatedAt: nowIso(),
+        },
+        history: [{ at: nowIso(), action: "create", note: "trackops init" }],
+      },
     ],
     findings: [],
   };
@@ -176,41 +227,117 @@ function installHooks(context) {
 
   if (fs.existsSync(path.join(context.workspaceRoot, ".git"))) {
     const hooksPath = context.layout === "split" ? "ops/.githooks" : ".githooks";
-    spawnSync("git", ["config", "core.hooksPath", hooksPath], { cwd: context.workspaceRoot, encoding: "utf8" });
+    const result = spawnSync("git", ["config", "core.hooksPath", hooksPath], { cwd: context.workspaceRoot, encoding: "utf8" });
+    if (result.status !== 0) {
+      console.log(t("cli.hooksError"));
+    }
   }
 }
 
-function ensureTmpDir(context) {
+function ensureTmpDir(context) {
   fs.mkdirSync(context.paths.tmpDir, { recursive: true });
   const gitkeep = path.join(context.paths.tmpDir, ".gitkeep");
   if (!fs.existsSync(gitkeep)) {
     fs.writeFileSync(gitkeep, "", "utf8");
-  }
-}
-
-function ensureSplitLayoutAllowed(targetRoot) {
-  const entries = fs.readdirSync(targetRoot, { withFileTypes: true });
-  const meaningful = entries.filter((entry) => ![".git"].includes(entry.name));
-  if (meaningful.length > 0) {
-    throw new Error("Directory is not empty. Run 'trackops workspace migrate' to convert an existing project.");
-  }
-}
-
-function initSplitProject(root, options) {
-  const targetRoot = path.resolve(root);
-  fs.mkdirSync(targetRoot, { recursive: true });
-  ensureSplitLayoutAllowed(targetRoot);
-
-  const manifest = workspace.buildManifest();
-  const context = config.createSplitContext(targetRoot, manifest);
-  fs.mkdirSync(context.appRoot, { recursive: true });
-  fs.mkdirSync(context.opsRoot, { recursive: true });
-  config.saveWorkspaceManifest(context, manifest);
-  workspace.ensureRootGitignore(targetRoot);
-
-  const control = buildDefaultControl(context, options);
-  control.meta.projectName = options.name || detectProjectName(context.workspaceRoot);
-  config.saveControl(context, control);
+  }
+}
+
+function isRetryableMoveError(error) {
+  return ["EPERM", "EXDEV", "EBUSY", "ENOTEMPTY"].includes(error?.code);
+}
+
+function moveEntry(fromPath, toPath) {
+  if (!fs.existsSync(fromPath)) return;
+  fs.mkdirSync(path.dirname(toPath), { recursive: true });
+  try {
+    fs.renameSync(fromPath, toPath);
+  } catch (error) {
+    if (!isRetryableMoveError(error)) throw error;
+    const stat = fs.statSync(fromPath);
+    if (stat.isDirectory()) {
+      fs.cpSync(fromPath, toPath, { recursive: true, force: true });
+      fs.rmSync(fromPath, { recursive: true, force: true });
+      return;
+    }
+    fs.copyFileSync(fromPath, toPath);
+    fs.rmSync(fromPath, { force: true });
+  }
+}
+
+function collectRootEntries(targetRoot) {
+  return fs.readdirSync(targetRoot, { withFileTypes: true })
+    .filter((entry) => ![".", ".."].includes(entry.name));
+}
+
+function analyzeSplitInit(targetRoot) {
+  const entries = collectRootEntries(targetRoot);
+  const manifestPath = path.join(targetRoot, config.WORKSPACE_MANIFEST);
+  const legacyControlPath = path.join(targetRoot, "project_control.json");
+  const hasManifest = fs.existsSync(manifestPath);
+
+  if (hasManifest) {
+    return { mode: "upgrade", entries };
+  }
+
+  if (fs.existsSync(legacyControlPath)) {
+    throw new Error(t("init.error.legacyDetected"));
+  }
+
+  const conflicts = entries
+    .map((entry) => entry.name)
+    .filter((name) => [config.DEFAULT_APP_DIR, config.DEFAULT_OPS_DIR, config.WORKSPACE_MANIFEST].includes(name));
+
+  if (conflicts.length) {
+    throw new Error(t("init.error.reservedConflict", { entries: conflicts.join(", ") }));
+  }
+
+  const movableEntries = entries.filter((entry) => !ROOT_PRESERVED_ENTRIES.has(entry.name));
+  return {
+    mode: movableEntries.length ? "adopt" : "new",
+    entries,
+    movableEntries,
+  };
+}
+
+function adoptExistingProject(targetRoot, appRoot, movableEntries) {
+  for (const entry of movableEntries) {
+    moveEntry(path.join(targetRoot, entry.name), path.join(appRoot, entry.name));
+  }
+}
+
+function initSplitProject(root, options) {
+  const targetRoot = path.resolve(root);
+  fs.mkdirSync(targetRoot, { recursive: true });
+  const projectName = options.name || detectProjectName(targetRoot);
+  const initMode = analyzeSplitInit(targetRoot);
+  const manifest = workspace.buildManifest();
+  const context = config.createSplitContext(targetRoot, manifest);
+
+  if (initMode.mode === "adopt") {
+    fs.mkdirSync(context.appRoot, { recursive: true });
+    adoptExistingProject(targetRoot, context.appRoot, initMode.movableEntries);
+  }
+
+  fs.mkdirSync(context.appRoot, { recursive: true });
+  fs.mkdirSync(context.opsRoot, { recursive: true });
+  config.saveWorkspaceManifest(context, manifest);
+  workspace.ensureRootGitignore(targetRoot);
+
+  const controlFile = context.controlFile || path.join(context.opsRoot, "project_control.json");
+  const isUpgrade = initMode.mode === "upgrade" && fs.existsSync(controlFile);
+  let control;
+  if (isUpgrade) {
+    control = JSON.parse(fs.readFileSync(controlFile, "utf8"));
+    if (!control.meta.phases) control.meta.phases = options.phases || config.buildDefaultPhases(options.locale);
+    if (!control.meta.locale) control.meta.locale = options.locale || config.DEFAULT_LOCALE;
+    if (!control.meta.controlVersion || control.meta.controlVersion < config.DEFAULT_CONTROL_VERSION) control.meta.controlVersion = config.DEFAULT_CONTROL_VERSION;
+    control.meta.updatedAt = nowIso();
+    config.saveControl(context, control);
+  } else {
+    control = buildDefaultControl(context, options);
+    control.meta.projectName = projectName;
+    config.saveControl(context, control);
+  }
 
   installHooks(context);
   ensureTmpDir(context);
@@ -224,16 +351,27 @@ function initSplitProject(root, options) {
     // ignore
   }
 
-  console.log(t("init.created", { file: ".trackops-workspace.json" }));
-  console.log(t("init.created", { file: "ops/project_control.json" }));
-  console.log(t("init.created", { file: "ops/.githooks/" }));
-  console.log(t("init.created", { file: ".env" }));
-  console.log(t("init.created", { file: ".env.example" }));
-  console.log("");
-  console.log(t("init.welcome"));
-
-  return { root: context.workspaceRoot, context, isUpgrade: false, operaDetected: false };
-}
+  if (isUpgrade) {
+    console.log(t("init.updated", { file: ".trackops-workspace.json" }));
+    console.log(t("init.updated", { file: "ops/project_control.json" }));
+    console.log(t("init.updated", { file: "ops/.githooks/" }));
+    console.log(t("init.updated", { file: ".env" }));
+    console.log(t("init.updated", { file: ".env.example" }));
+  } else {
+    console.log(t("init.created", { file: ".trackops-workspace.json" }));
+    console.log(t("init.created", { file: "ops/project_control.json" }));
+    console.log(t("init.created", { file: "ops/.githooks/" }));
+    console.log(t("init.created", { file: ".env" }));
+    console.log(t("init.created", { file: ".env.example" }));
+    if (initMode.mode === "adopt") {
+      console.log(t("init.adoptedExistingRepo", { dir: path.basename(context.appRoot) }));
+    }
+  }
+  console.log("");
+  console.log(t("init.welcome"));
+
+  return { root: context.workspaceRoot, context, isUpgrade, operaDetected: false };
+}
 
 function initLegacyProject(root, options) {
   const targetRoot = path.resolve(root);
@@ -250,7 +388,7 @@ function initLegacyProject(root, options) {
     const existing = JSON.parse(fs.readFileSync(controlFile, "utf8"));
     if (!existing.meta.phases) existing.meta.phases = options.phases || config.buildDefaultPhases(options.locale);
     if (!existing.meta.locale) existing.meta.locale = options.locale || config.DEFAULT_LOCALE;
-    if (!existing.meta.controlVersion || existing.meta.controlVersion < 2) existing.meta.controlVersion = 2;
+    if (!existing.meta.controlVersion || existing.meta.controlVersion < config.DEFAULT_CONTROL_VERSION) existing.meta.controlVersion = config.DEFAULT_CONTROL_VERSION;
     existing.meta.updatedAt = nowIso();
     fs.writeFileSync(controlFile, `${JSON.stringify(existing, null, 2)}\n`, "utf8");
     console.log(t("init.updated", { file: "project_control.json" }));