trackops 1.0.0 → 1.1.0

package/lib/env.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const config = require("./config");
+
+const SERVICE_ENV_KEYS = {
+  OpenAI: ["OPENAI_API_KEY"],
+  Anthropic: ["ANTHROPIC_API_KEY"],
+  Stripe: ["STRIPE_SECRET_KEY", "STRIPE_WEBHOOK_SECRET"],
+  Supabase: ["SUPABASE_URL", "SUPABASE_ANON_KEY", "SUPABASE_SERVICE_ROLE_KEY"],
+  PostgreSQL: ["DATABASE_URL"],
+  MySQL: ["DATABASE_URL"],
+  Redis: ["REDIS_URL"],
+  Slack: ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"],
+  "Amazon S3": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION", "AWS_S3_BUCKET"],
+  AWS: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"],
+  "Google Cloud": ["GOOGLE_APPLICATION_CREDENTIALS"],
+  Azure: ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"],
+};
+
+function unique(items) {
+  return [...new Set((items || []).map((item) => String(item || "").trim()).filter(Boolean))];
+}
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+}
+
+function parseEnv(text) {
+  const entries = {};
+  const lines = String(text || "").split(/\r?\n/);
+  for (const line of lines) {
+    if (!line || /^\s*#/.test(line)) continue;
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+    if (!match) continue;
+    entries[match[1]] = match[2] || "";
+  }
+  return entries;
+}
+
+function parseEnvKeys(text) {
+  return unique(Object.keys(parseEnv(text)));
+}
+
+function normalizeEnvironmentMeta(control, context) {
+  const envMeta = control.meta?.environment || {};
+  return {
+    rootEnvFile: envMeta.rootEnvFile || path.relative(context.workspaceRoot, context.env.rootFile).replace(/\\/g, "/"),
+    exampleFile: envMeta.exampleFile || path.relative(context.workspaceRoot, context.env.exampleFile).replace(/\\/g, "/"),
+    appBridgeFile: envMeta.appBridgeFile || path.relative(context.workspaceRoot, context.env.appBridgeFile).replace(/\\/g, "/"),
+    bridgeMode: envMeta.bridgeMode || (context.layout === "split" ? "symlink-or-copy" : "none"),
+    requiredKeys: unique(envMeta.requiredKeys),
+    optionalKeys: unique(envMeta.optionalKeys),
+    lastAuditAt: envMeta.lastAuditAt || null,
+  };
+}
+
+function inferRequiredKeys(control, contextOrRoot) {
+  const envMeta = control.meta?.environment || {};
+  const fromMeta = unique([...(envMeta.requiredKeys || []), ...(envMeta.optionalKeys || [])]);
+  const fromServices = unique(
+    (control.meta?.opera?.bootstrap?.discovery?.externalServices || [])
+      .flatMap((service) => SERVICE_ENV_KEYS[service] || []),
+  );
+  const context = config.ensureContext(contextOrRoot || process.cwd());
+  const fromExample = parseEnvKeys(readText(context.env.exampleFile));
+  return unique([...fromMeta, ...fromServices, ...fromExample]);
+}
+
+function ensureFileWithHeader(filePath, lines) {
+  if (fs.existsSync(filePath)) return;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${lines.join("\n")}\n`, "utf8");
+}
+
+function appendMissingKeys(filePath, keys, heading) {
+  const existing = readText(filePath);
+  const parsed = parseEnvKeys(existing);
+  const missing = unique(keys).filter((key) => !parsed.includes(key));
+  if (!missing.length) return;
+
+  const chunks = [];
+  if (existing.trim()) chunks.push("");
+  if (heading) chunks.push(heading);
+  missing.forEach((key) => chunks.push(`${key}=`));
+  fs.appendFileSync(filePath, `${chunks.join("\n")}\n`, "utf8");
+}
+
+function safeUnlink(filePath) {
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch (_error) {
+    // noop
+  }
+}
+
+function ensureBridge(context, control) {
+  const envMeta = normalizeEnvironmentMeta(control, context);
+  const bridgePath = context.env.appBridgeFile;
+  const exampleBridgePath = context.env.appExampleBridgeFile;
+  const sourceEnv = context.env.rootFile;
+  const sourceExample = context.env.exampleFile;
+
+  if (context.layout !== "split") {
+    control.meta.environment = { ...envMeta, bridgeMode: "none" };
+    return "none";
+  }
+
+  fs.mkdirSync(path.dirname(bridgePath), { recursive: true });
+
+  let mode = "copy";
+  safeUnlink(bridgePath);
+  try {
+    fs.symlinkSync(path.relative(path.dirname(bridgePath), sourceEnv), bridgePath, "file");
+    mode = "symlink";
+  } catch (_error) {
+    fs.copyFileSync(sourceEnv, bridgePath);
+  }
+
+  safeUnlink(exampleBridgePath);
+  try {
+    fs.symlinkSync(path.relative(path.dirname(exampleBridgePath), sourceExample), exampleBridgePath, "file");
+  } catch (_error) {
+    fs.copyFileSync(sourceExample, exampleBridgePath);
+  }
+
+  control.meta.environment = {
+    ...envMeta,
+    bridgeMode: mode,
+  };
+  return mode;
+}
+
+function syncEnvironment(contextOrRoot, controlState, options = {}) {
+  const context = config.ensureContext(contextOrRoot);
+  const control = controlState || config.loadControl(context);
+  control.meta = control.meta || {};
+  control.meta.environment = normalizeEnvironmentMeta(control, context);
+
+  const requiredKeys = unique(options.requiredKeys || inferRequiredKeys(control, context));
+  const optionalKeys = unique(options.optionalKeys || control.meta.environment.optionalKeys);
+
+  ensureFileWithHeader(context.env.rootFile, [
+    "# TrackOps workspace secrets",
+    "# Do not commit this file.",
+  ]);
+  ensureFileWithHeader(context.env.exampleFile, [
+    "# TrackOps workspace environment contract",
+    "# Safe to commit. Keep only keys, never real values.",
+  ]);
+
+  appendMissingKeys(context.env.rootFile, requiredKeys, "# Required keys");
+  appendMissingKeys(context.env.exampleFile, requiredKeys, "# Required keys");
+  appendMissingKeys(context.env.exampleFile, optionalKeys, "# Optional keys");
+
+  const bridgeMode = ensureBridge(context, control);
+  control.meta.environment = {
+    ...control.meta.environment,
+    requiredKeys,
+    optionalKeys,
+    bridgeMode,
+    lastAuditAt: new Date().toISOString(),
+  };
+
+  config.saveControl(context, control);
+  return auditEnvironment(context, control);
+}
+
+function auditEnvironment(contextOrRoot, controlState) {
+  const context = config.ensureContext(contextOrRoot);
+  const control = controlState || config.loadControl(context);
+  const envMeta = normalizeEnvironmentMeta(control, context);
+  const requiredKeys = unique(envMeta.requiredKeys.length ? envMeta.requiredKeys : inferRequiredKeys(control, context));
+  const envEntries = parseEnv(readText(context.env.rootFile));
+  const presentKeys = requiredKeys.filter((key) => String(envEntries[key] || "").trim());
+  const missingKeys = requiredKeys.filter((key) => !String(envEntries[key] || "").trim());
+
+  return {
+    ok: true,
+    files: {
+      rootEnv: context.env.rootFile,
+      rootExample: context.env.exampleFile,
+      appBridge: context.env.appBridgeFile,
+    },
+    bridgeMode: envMeta.bridgeMode,
+    requiredKeys,
+    optionalKeys: envMeta.optionalKeys,
+    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(", ")}`);
+  }
+}
+
+module.exports = {
+  SERVICE_ENV_KEYS,
+  parseEnv,
+  parseEnvKeys,
+  normalizeEnvironmentMeta,
+  inferRequiredKeys,
+  syncEnvironment,
+  auditEnvironment,
+  cmdStatus,
+  cmdSync,
+};

package/lib/i18n.js

@@ -1,53 +1,61 @@
-#!/usr/bin/env node
-
-const path = require("path");
-
-const LOCALES_DIR = path.join(__dirname, "..", "locales");
-
-let currentLocale = "es";
-let currentMessages = null;
-let fallbackMessages = null;
-
-function loadMessages(localeId) {
-  try {
-    return require(path.join(LOCALES_DIR, `${localeId}.json`));
-  } catch (_error) {
-    return null;
-  }
-}
-
-function ensureLoaded() {
-  if (currentMessages) return;
-  currentMessages = loadMessages(currentLocale) || {};
-  if (currentLocale !== "es") {
-    fallbackMessages = loadMessages("es") || {};
-  } else {
-    fallbackMessages = currentMessages;
-  }
-}
-
-function setLocale(localeId) {
-  currentLocale = localeId || "es";
-  currentMessages = null;
-  fallbackMessages = null;
-}
-
-function getLocale() {
-  return currentLocale;
-}
-
-function t(key, params) {
-  ensureLoaded();
-  let message =
-    currentMessages[key] ||
-    (fallbackMessages && fallbackMessages[key]) ||
-    key;
-  if (params) {
-    message = message.replace(/\{(\w+)\}/g, (match, paramKey) =>
-      params[paramKey] !== undefined ? String(params[paramKey]) : match
-    );
-  }
-  return message;
-}
-
-module.exports = { setLocale, getLocale, t };
+#!/usr/bin/env node
+
+const path = require("path");
+
+const LOCALES_DIR = path.join(__dirname, "..", "locales");
+
+let currentLocale = "es";
+let currentMessages = null;
+let fallbackMessages = null;
+
+function loadMessages(localeId) {
+  try {
+    return require(path.join(LOCALES_DIR, `${localeId}.json`));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function ensureLoaded() {
+  if (currentMessages) return;
+  currentMessages = loadMessages(currentLocale) || {};
+  if (currentLocale !== "es") {
+    fallbackMessages = loadMessages("es") || {};
+  } else {
+    fallbackMessages = currentMessages;
+  }
+}
+
+function setLocale(localeId) {
+  currentLocale = localeId || "es";
+  currentMessages = null;
+  fallbackMessages = null;
+}
+
+function getLocale() {
+  return currentLocale;
+}
+
+function t(key, params) {
+  ensureLoaded();
+  let message =
+    currentMessages[key] ||
+    (fallbackMessages && fallbackMessages[key]) ||
+    key;
+  if (params) {
+    message = message.replace(/\{(\w+)\}/g, (match, paramKey) =>
+      params[paramKey] !== undefined ? String(params[paramKey]) : match
+    );
+  }
+  return message;
+}
+
+function getMessages(localeId) {
+  const locale = localeId || currentLocale || "es";
+  return {
+    ...(locale !== "es" ? (loadMessages("es") || {}) : {}),
+    ...(loadMessages(locale) || {}),
+  };
+}
+
+module.exports = { setLocale, getLocale, t, getMessages };

package/lib/init.js

@@ -4,20 +4,42 @@ const fs = require("fs");
 const path = require("path");
 const { spawnSync } = require("child_process");
 
-const { DEFAULT_PHASES, DEFAULT_LOCALE } = require("./config");
+const config = require("./config");
 const registry = require("./registry");
+const env = require("./env");
+const workspace = require("./workspace");
 const { t, setLocale } = require("./i18n");
+const { detectSystemLocale, promptForLocale, resolveLocale } = require("./locale");
+
+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",
+};
 
 function nowIso() {
   return new Date().toISOString();
 }
 
 function parseArgs(args) {
-  const options = { locale: null, name: null, withOpera: false, phases: null };
+  const options = {
+    locale: null,
+    name: null,
+    withOpera: false,
+    phases: null,
+    noBootstrap: false,
+    legacyLayout: false,
+  };
   for (let i = 0; i < args.length; i += 1) {
     if (args[i] === "--locale" && args[i + 1]) { options.locale = args[i + 1]; i += 1; }
     else if (args[i] === "--name" && args[i + 1]) { options.name = args[i + 1]; i += 1; }
     else if (args[i] === "--with-opera" || args[i] === "--with-etapa") { options.withOpera = true; }
+    else if (args[i] === "--no-bootstrap") { options.noBootstrap = true; }
+    else if (args[i] === "--legacy-layout") { options.legacyLayout = true; }
     else if (args[i] === "--phases" && args[i + 1]) {
       try { options.phases = JSON.parse(args[i + 1]); } catch (_e) { /* ignore */ }
       i += 1;
@@ -32,20 +54,17 @@ function detectProjectName(root) {
     try {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
       return pkg.displayName || pkg.name || path.basename(root);
-    } catch (_e) { /* ignore */ }
+    } catch (_e) {
+      // noop
+    }
   }
   return path.basename(root);
 }
 
-function hasExistingOpera(root) {
-  return (
-    fs.existsSync(path.join(root, ".agent", "hub")) ||
-    fs.existsSync(path.join(root, ".agents", "skills"))
-  );
-}
-
-function buildDefaultControl(options) {
-  const locale = options.locale || DEFAULT_LOCALE;
+function buildDefaultControl(context, options) {
+  const locale = resolveLocale(options.locale, config.DEFAULT_LOCALE);
+  const phases = options.phases || config.buildDefaultPhases(locale);
+  const isSplit = context.layout === "split";
   setLocale(locale);
 
   return {
@@ -53,12 +72,30 @@ function buildDefaultControl(options) {
       projectName: options.name || "My Project",
       controlVersion: 2,
       locale,
-      phases: options.phases || DEFAULT_PHASES,
+      phases,
       updatedAt: nowIso(),
       executionSource: "project_control.json",
       currentFocus: t("init.defaultFocus"),
-      focusPhase: (options.phases || DEFAULT_PHASES)[0]?.id || "E",
+      focusPhase: phases[0]?.id || "O",
       deliveryTarget: t("init.defaultTarget"),
+      workspace: isSplit ? {
+        layout: "split",
+        workspaceRoot: ".",
+        appDir: path.basename(context.appRoot),
+        opsDir: path.basename(context.opsRoot),
+        developmentBranch: context.branches.development,
+        publishBranch: context.branches.publish,
+        publishMode: context.publish.mode,
+      } : undefined,
+      environment: {
+        rootEnvFile: path.relative(context.workspaceRoot, context.env.rootFile).replace(/\\/g, "/"),
+        exampleFile: path.relative(context.workspaceRoot, context.env.exampleFile).replace(/\\/g, "/"),
+        appBridgeFile: path.relative(context.workspaceRoot, context.env.appBridgeFile).replace(/\\/g, "/"),
+        bridgeMode: isSplit ? "symlink-or-copy" : "none",
+        requiredKeys: [],
+        optionalKeys: [],
+        lastAuditAt: null,
+      },
     },
     checks: {
       lastBuild: { status: "pending", date: null, note: "" },
@@ -77,7 +114,7 @@ function buildDefaultControl(options) {
       {
         id: "ops-bootstrap",
         title: t("init.defaultTaskTitle"),
-        phase: (options.phases || DEFAULT_PHASES)[0]?.id || "E",
+        phase: phases[0]?.id || "O",
         stream: "Operations",
         priority: "P0",
         status: "pending",
@@ -99,62 +136,106 @@ function upsertScripts(root) {
     try { pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8")); } catch (_e) { /* ignore */ }
   }
   pkg.scripts = pkg.scripts || {};
-  Object.assign(pkg.scripts, {
-    ops: "trackops",
-    "ops:help": "trackops help",
-    "ops:dashboard": "trackops dashboard",
-    "ops:status": "trackops status",
-    "ops:next": "trackops next",
-    "ops:sync": "trackops sync",
-    "ops:repo": "trackops refresh-repo",
-  });
+  Object.assign(pkg.scripts, GENERATED_SCRIPT_COMMANDS);
   fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
 }
 
-function installHooks(root) {
-  const hooksDir = path.join(root, ".githooks");
+function installHooks(context) {
+  const hooksDir = context.paths.hooksDir;
   fs.mkdirSync(hooksDir, { recursive: true });
 
-  const hookContent = "#!/bin/sh\nnpx trackops refresh-repo --quiet >/dev/null 2>&1 || true\n";
+  const relativeCommand = context.layout === "split"
+    ? "npx --yes trackops refresh-repo --quiet >/dev/null 2>&1 || true\n"
+    : "npx --yes trackops refresh-repo --quiet >/dev/null 2>&1 || true\n";
+  const hookContent = `#!/bin/sh\n${relativeCommand}`;
   for (const hookName of ["post-commit", "post-checkout", "post-merge"]) {
     const hookPath = path.join(hooksDir, hookName);
     fs.writeFileSync(hookPath, hookContent, { mode: 0o755 });
   }
 
-  if (fs.existsSync(path.join(root, ".git"))) {
-    spawnSync("git", ["config", "core.hooksPath", ".githooks"], { cwd: root, encoding: "utf8" });
+  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" });
   }
 }
 
-function ensureTmpDir(root) {
-  const tmpDir = path.join(root, ".tmp");
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const gitkeep = path.join(tmpDir, ".gitkeep");
+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 initProject(root, options) {
+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.appRoot);
+  config.saveControl(context, control);
+
+  installHooks(context);
+  ensureTmpDir(context);
+  const controlApi = require("./control");
+  controlApi.syncDocs(context, control);
+  env.syncEnvironment(context, control);
+
+  try {
+    registry.registerProject(context.workspaceRoot);
+  } catch (_e) {
+    // 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 };
+}
+
+function initLegacyProject(root, options) {
   const targetRoot = path.resolve(root);
-  const controlFile = path.join(targetRoot, "project_control.json");
+  const context = config.createLegacyContext(targetRoot);
+  const controlFile = context.controlFile;
   const isUpgrade = fs.existsSync(controlFile);
+  options.locale = resolveLocale(options.locale, detectSystemLocale());
 
   if (!options.name) {
     options.name = detectProjectName(targetRoot);
   }
 
   if (isUpgrade) {
-    // Upgrade: add new meta fields if missing
     const existing = JSON.parse(fs.readFileSync(controlFile, "utf8"));
-    if (!existing.meta.phases) existing.meta.phases = options.phases || DEFAULT_PHASES;
-    if (!existing.meta.locale) existing.meta.locale = options.locale || DEFAULT_LOCALE;
+    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;
     existing.meta.updatedAt = nowIso();
     fs.writeFileSync(controlFile, `${JSON.stringify(existing, null, 2)}\n`, "utf8");
     console.log(t("init.updated", { file: "project_control.json" }));
   } else {
-    const control = buildDefaultControl(options);
+    const control = buildDefaultControl(context, options);
+    control.meta.projectName = options.name;
     fs.writeFileSync(controlFile, `${JSON.stringify(control, null, 2)}\n`, "utf8");
     console.log(t("init.created", { file: "project_control.json" }));
   }
@@ -162,38 +243,48 @@ function initProject(root, options) {
   upsertScripts(targetRoot);
   console.log(t("init.updated", { file: "package.json" }));
 
-  installHooks(targetRoot);
+  installHooks(context);
   console.log(t("init.created", { file: ".githooks/" }));
-
-  ensureTmpDir(targetRoot);
+  ensureTmpDir(context);
 
   try {
     registry.registerProject(targetRoot);
     console.log(t("init.registered"));
-  } catch (_e) { /* ignore */ }
-
-  const operaDetected = hasExistingOpera(targetRoot);
+  } catch (_e) {
+    // ignore
+  }
 
   console.log("");
   console.log(t("init.welcome"));
+  return { root: targetRoot, context, isUpgrade, operaDetected: false };
+}
 
-  return { root: targetRoot, isUpgrade, operaDetected };
+function initProject(root, options) {
+  const normalized = { ...(options || {}) };
+  normalized.locale = resolveLocale(normalized.locale, config.DEFAULT_LOCALE);
+  setLocale(normalized.locale);
+  if (normalized.legacyLayout) {
+    return initLegacyProject(root, normalized);
+  }
+  return initSplitProject(root, normalized);
 }
 
-function cmdInit(args) {
+async function cmdInit(args) {
   const options = parseArgs(args || []);
-  const root = process.cwd();
-  setLocale(options.locale || DEFAULT_LOCALE);
+  options.locale = resolveLocale(options.locale, null);
+  if (!options.locale) {
+    options.locale = await promptForLocale(detectSystemLocale());
+  }
+  setLocale(options.locale || config.DEFAULT_LOCALE);
 
-  const result = initProject(root, options);
+  const result = initProject(process.cwd(), options);
 
   if (options.withOpera) {
     const opera = require("./opera");
-    opera.install(root, {});
-  } else if (result.operaDetected) {
-    console.log("");
-    console.log(t("opera.primitiveDetected"));
-    console.log("  Run 'trackops opera install' to upgrade to managed OPERA.");
+    await opera.install(result.root, {
+      locale: options.locale,
+      bootstrap: !options.noBootstrap,
+    });
   }
 }