trackops 1.0.1 → 2.0.0

package/lib/skills.js

@@ -1,62 +1,63 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-
-const config = require("./config");
-const { t, setLocale } = require("./i18n");
-
-const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
-
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const config = require("./config");
+const { t, setLocale } = require("./i18n");
+const { resolveSkillFile } = require("./resources");
+
+const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
+
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 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;
-    }
-  }
+  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 getSkillsDir(root) {
-  return path.join(root, ".agents", "skills");
+  return config.ensureContext(root).paths.skillsDir;
 }
 
 function getRegistryPath(root) {
-  return path.join(root, ".agents", "skills", "_registry.md");
-}
-
-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);
+  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 installedSkills(root) {
   const skillsDir = getSkillsDir(root);
   if (!fs.existsSync(skillsDir)) return [];
@@ -65,95 +66,118 @@ function installedSkills(root) {
     .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 updateRegistry(root) {
-  const registryPath = getRegistryPath(root);
-  fs.mkdirSync(path.dirname(registryPath), { recursive: true });
-  const skills = installedSkills(root);
-  const lines = ["# Skills Registry", "", "| Skill | Version | Description |", "|-------|---------|-------------|"];
-  for (const s of skills) {
-    lines.push(`| ${s.name} | ${s.version} | ${s.description} |`);
-  }
-  fs.writeFileSync(registryPath, lines.join("\n") + "\n", "utf8");
-
-  // Also update control meta
-  const controlFile = config.controlFilePath(root);
+
+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 {
-      const control = config.loadControl(root);
+      locale = config.getLocale(config.loadControl(context));
+      setLocale(locale);
+    } catch (_error) {
+      setLocale("es");
+    }
+  }
+  const skills = installedSkills(root);
+  const header = locale === "en" ? "# Skills Registry" : "# Skills Registry";
+  const empty = locale === "en"
+    ? "_No skills installed yet. Use `trackops skill install <name>` to add one._"
+    : "_Sin skills instaladas. Usa `trackops skill install <nombre>` para añadir una._";
+  const lines = [header, "", "| Skill | Version | Description |", "|-------|---------|-------------|"];
+  for (const s of skills) {
+    lines.push(`| ${s.name} | ${s.version} | ${s.description} |`);
+  }
+  if (!skills.length) lines.push("", empty);
+  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(root, control);
+        config.saveControl(context, control);
       }
-    } catch (_e) { /* ignore */ }
-  }
-}
-
+    } catch (_e) { /* ignore */ }
+  }
+}
+
 function installSkill(root, skillName) {
-  const control = config.loadControl(root);
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
   setLocale(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(root), skillName);
-  if (fs.existsSync(path.join(targetDir, "SKILL.md"))) {
-    console.log(t("skill.alreadyInstalled", { name: skillName }));
-    return;
-  }
-
-  copyDirRecursive(templateDir, targetDir);
-  updateRegistry(root);
+  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);
+  if (fs.existsSync(path.join(targetDir, "SKILL.md"))) {
+    console.log(t("skill.alreadyInstalled", { name: skillName }));
+    return;
+  }
+
+  copyDirRecursive(templateDir, targetDir);
+  const localizedSkill = resolveSkillFile(SKILLS_TEMPLATES_DIR, skillName, locale);
+  if (localizedSkill) {
+    fs.copyFileSync(localizedSkill, path.join(targetDir, "SKILL.md"));
+  }
+  updateRegistry(context);
   console.log(t("skill.installed", { name: skillName }));
 }
 
 function removeSkill(root, skillName) {
-  const control = config.loadControl(root);
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
   setLocale(config.getLocale(control));
 
-  const targetDir = path.join(getSkillsDir(root), skillName);
-  if (!fs.existsSync(targetDir)) {
-    console.log(t("skill.notInstalled", { name: skillName }));
-    return;
-  }
-
-  fs.rmSync(targetDir, { recursive: true, force: true });
-  updateRegistry(root);
+  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 }));
 }
-
-/* ── CLI commands ── */
-
-function cmdInstall(root, skillName) {
-  if (!skillName) { console.error("Skill name required."); process.exit(1); }
-  installSkill(root, skillName);
-}
-
-function cmdList(root) {
-  const skills = installedSkills(root);
-  if (!skills.length) { console.log("No skills installed."); return; }
-  console.log(t("skill.listTitle"));
-  for (const s of skills) {
-    console.log(`  ${s.name} (v${s.version}) — ${s.description}`);
-  }
-}
-
-function cmdRemove(root, skillName) {
-  if (!skillName) { console.error("Skill name required."); process.exit(1); }
-  removeSkill(root, skillName);
-}
-
-function cmdCatalog() {
-  const skills = catalogSkills();
-  if (!skills.length) { console.log("No skills available in catalog."); return; }
-  console.log(t("skill.catalogTitle"));
-  for (const s of skills) {
-    console.log(`  ${s.name} (v${s.version}) — ${s.description}`);
-  }
-}
-
-module.exports = { installSkill, removeSkill, installedSkills, catalogSkills, updateRegistry, cmdInstall, cmdList, cmdRemove, cmdCatalog };
+
+/* ── CLI commands ── */
+
+function cmdInstall(root, skillName) {
+  if (!skillName) { console.error("Skill name required."); process.exit(1); }
+  installSkill(root, skillName);
+}
+
+function cmdList(root) {
+  const skills = installedSkills(root);
+  if (!skills.length) { console.log("No skills installed."); return; }
+  console.log(t("skill.listTitle"));
+  for (const s of skills) {
+    console.log(`  ${s.name} (v${s.version}) — ${s.description}`);
+  }
+}
+
+function cmdRemove(root, skillName) {
+  if (!skillName) { console.error("Skill name required."); process.exit(1); }
+  removeSkill(root, skillName);
+}
+
+function cmdCatalog() {
+  const skills = catalogSkills();
+  if (!skills.length) { console.log("No skills available in catalog."); return; }
+  console.log(t("skill.catalogTitle"));
+  for (const s of skills) {
+    console.log(`  ${s.name} (v${s.version}) — ${s.description}`);
+  }
+}
+
+module.exports = { installSkill, removeSkill, installedSkills, catalogSkills, updateRegistry, cmdInstall, cmdList, cmdRemove, cmdCatalog };

package/lib/workspace.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const config = require("./config");
+const registry = require("./registry");
+const env = require("./env");
+
+const OPS_ARTIFACTS = [
+  "project_control.json",
+  "task_plan.md",
+  "progress.md",
+  "findings.md",
+  "genesis.md",
+  ".agent",
+  ".agents",
+  ".githooks",
+  ".tmp",
+];
+
+function nowStamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function git(args, cwd) {
+  return spawnSync("git", args, { cwd, encoding: "utf8" });
+}
+
+function isIgnorableDirtyLine(line) {
+  const normalized = String(line || "").replace(/\\/g, "/");
+  return normalized.endsWith(".tmp/project-control-runtime.json");
+}
+
+function isRetryableMoveError(error) {
+  return ["EPERM", "EXDEV", "EBUSY", "ENOTEMPTY"].includes(error?.code);
+}
+
+function assertCleanGit(root, allowDirty = false) {
+  const status = git(["status", "--porcelain"], root);
+  const dirtyLines = String(status.stdout || "")
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .filter((line) => !isIgnorableDirtyLine(line));
+  if (!allowDirty && dirtyLines.length > 0) {
+    throw new Error("Workspace migration requires a clean git worktree.");
+  }
+}
+
+function createBackupBranch(root) {
+  const name = `backup/trackops-workspace-${nowStamp()}`;
+  const result = git(["branch", name], root);
+  if (result.status !== 0) {
+    throw new Error(result.stderr || `Could not create backup branch ${name}`);
+  }
+  return name;
+}
+
+function buildManifest() {
+  return {
+    version: 1,
+    layout: "split",
+    appDir: config.DEFAULT_APP_DIR,
+    opsDir: config.DEFAULT_OPS_DIR,
+    env: {
+      rootFile: ".env",
+      exampleFile: ".env.example",
+      appBridgeFile: "app/.env",
+      bridgeMode: "symlink-or-copy",
+    },
+    branches: {
+      development: config.DEFAULT_DEV_BRANCH,
+      publish: config.DEFAULT_PUBLISH_BRANCH,
+    },
+    publish: {
+      mode: "subtree-flatten",
+      sourceDir: config.DEFAULT_APP_DIR,
+      includeRootFiles: [".env.example"],
+      requireCleanWorktree: true,
+    },
+  };
+}
+
+function ensureRootGitignore(workspaceRoot) {
+  const gitignorePath = path.join(workspaceRoot, ".gitignore");
+  const required = ["/.env", "/app/.env", "/ops/.tmp/"];
+  let lines = [];
+  if (fs.existsSync(gitignorePath)) {
+    lines = fs.readFileSync(gitignorePath, "utf8").split(/\r?\n/);
+  }
+  for (const entry of required) {
+    if (!lines.includes(entry)) lines.push(entry);
+  }
+  fs.writeFileSync(gitignorePath, `${lines.filter(Boolean).join("\n")}\n`, "utf8");
+}
+
+function stripOpsScripts(packageFile) {
+  if (!fs.existsSync(packageFile)) return;
+  const pkg = JSON.parse(fs.readFileSync(packageFile, "utf8"));
+  if (!pkg.scripts) return;
+  ["ops", "ops:help", "ops:dashboard", "ops:status", "ops:next", "ops:sync", "ops:repo"].forEach((key) => {
+    delete pkg.scripts[key];
+  });
+  fs.writeFileSync(packageFile, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+}
+
+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 shouldResumePartialMigration(root, manifest) {
+  if (!fs.existsSync(path.join(root, config.WORKSPACE_MANIFEST))) return false;
+  const excluded = new Set([
+    ".git",
+    config.WORKSPACE_MANIFEST,
+    manifest.appDir,
+    manifest.opsDir,
+    ".env",
+    ".env.example",
+  ]);
+  const hasPendingOps = OPS_ARTIFACTS.some((entry) => fs.existsSync(path.join(root, entry)));
+  const hasPendingAppEntries = fs.readdirSync(root, { withFileTypes: true })
+    .some((entry) => !excluded.has(entry.name));
+  return hasPendingOps || hasPendingAppEntries;
+}
+
+function migrateWorkspace(rootDir, options = {}) {
+  const resolved = config.resolveWorkspaceContext(rootDir);
+  if (!resolved) {
+    throw new Error("workspace migrate only applies to legacy TrackOps projects.");
+  }
+
+  const root = resolved.workspaceRoot;
+  let manifest;
+  if (resolved.layout === "legacy") {
+    manifest = buildManifest();
+  } else {
+    manifest = config.loadWorkspaceManifest(resolved) || buildManifest();
+    if (!shouldResumePartialMigration(root, manifest)) {
+      throw new Error("workspace migrate only applies to legacy TrackOps projects.");
+    }
+  }
+
+  assertCleanGit(root, options.allowDirty === true);
+  const backupBranch = createBackupBranch(root);
+
+  const appDir = path.join(root, manifest.appDir);
+  const opsDir = path.join(root, manifest.opsDir);
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.mkdirSync(opsDir, { recursive: true });
+  config.saveWorkspaceManifest(config.createSplitContext(root, manifest), manifest);
+
+  for (const entry of OPS_ARTIFACTS) {
+    moveEntry(path.join(root, entry), path.join(opsDir, entry));
+  }
+
+  const excluded = new Set([
+    ".git",
+    config.WORKSPACE_MANIFEST,
+    manifest.appDir,
+    manifest.opsDir,
+    ".env",
+    ".env.example",
+  ]);
+
+  const topLevel = fs.readdirSync(root, { withFileTypes: true });
+  for (const entry of topLevel) {
+    if (excluded.has(entry.name)) continue;
+    moveEntry(path.join(root, entry.name), path.join(appDir, entry.name));
+  }
+
+  ensureRootGitignore(root);
+  stripOpsScripts(path.join(appDir, "package.json"));
+
+  const context = config.createSplitContext(root, manifest);
+  const control = config.loadControl(context);
+  control.meta = control.meta || {};
+  control.meta.workspace = {
+    layout: "split",
+    workspaceRoot: ".",
+    appDir: manifest.appDir,
+    opsDir: manifest.opsDir,
+    developmentBranch: manifest.branches.development,
+    publishBranch: manifest.branches.publish,
+    publishMode: manifest.publish.mode,
+  };
+  control.meta.environment = {
+    ...(control.meta.environment || {}),
+    rootEnvFile: ".env",
+    exampleFile: ".env.example",
+    appBridgeFile: "app/.env",
+    bridgeMode: "symlink-or-copy",
+    requiredKeys: control.meta.environment?.requiredKeys || [],
+    optionalKeys: control.meta.environment?.optionalKeys || [],
+    lastAuditAt: control.meta.environment?.lastAuditAt || null,
+  };
+  config.saveControl(context, control);
+  env.syncEnvironment(context, control);
+  const controlApi = require("./control");
+  controlApi.syncDocs(context, config.loadControl(context));
+  controlApi.refreshRepoRuntime(context, { quiet: true });
+
+  const hookConfig = git(["config", "core.hooksPath", "ops/.githooks"], root);
+  if (hookConfig.status !== 0) {
+    throw new Error(hookConfig.stderr || "Could not update git hooks path.");
+  }
+
+  registry.registerProject(root);
+  return { root, backupBranch, context };
+}
+
+function status(contextOrRoot) {
+  const context = config.ensureContext(contextOrRoot);
+  console.log("Workspace:");
+  console.log(`  Layout: ${context.layout}`);
+  console.log(`  Root: ${context.workspaceRoot}`);
+  console.log(`  App: ${context.appRoot}`);
+  console.log(`  Ops: ${context.opsRoot}`);
+  if (context.manifestFile) {
+    console.log(`  Manifest: ${context.manifestFile}`);
+  }
+  console.log(`  Control: ${context.controlFile}`);
+}
+
+function cmdStatus(root) {
+  status(root);
+}
+
+function cmdMigrate(root, args = []) {
+  const allowDirty = args.includes("--allow-dirty");
+  const result = migrateWorkspace(root, { allowDirty });
+  console.log(`Workspace migrated: ${result.root}`);
+  console.log(`Backup branch: ${result.backupBranch}`);
+}
+
+module.exports = {
+  OPS_ARTIFACTS,
+  buildManifest,
+  ensureRootGitignore,
+  stripOpsScripts,
+  migrateWorkspace,
+  status,
+  cmdStatus,
+  cmdMigrate,
+};