superlab 0.1.5 → 0.1.6

package/bin/superlab.cjs

@@ -2,7 +2,9 @@
 
 const path = require("node:path");
 const {
+  PACKAGE_VERSION,
   detectLanguage,
+  getProjectVersionInfo,
   installSuperlab,
   updateAllProjects,
   updateSuperlabProject,
@@ -17,11 +19,13 @@ Usage:
   superlab install [--target <dir>] [--platform codex|claude|both|all] [--lang en|zh] [--force]
   superlab update [--target <dir>]
   superlab update --all-projects
+  superlab version [--target <dir>] [--global|--project]
 
 Commands:
   init      Initialize /lab commands, skills, templates, and scripts in a target
   install   Backward-compatible alias for init
   update    Refresh an initialized project or all registered projects
+  version   Show installed CLI version and project asset version
   help      Show this help message
 `);
 }
@@ -89,6 +93,56 @@ function parseUpdateArgs(argv) {
   return options;
 }
 
+function parseVersionArgs(argv) {
+  const options = {
+    targetDir: process.cwd(),
+    globalOnly: false,
+    projectOnly: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === "--target") {
+      options.targetDir = path.resolve(argv[index + 1]);
+      index += 1;
+    } else if (value === "--global") {
+      options.globalOnly = true;
+    } else if (value === "--project") {
+      options.projectOnly = true;
+    } else {
+      throw new Error(`Unknown option: ${value}`);
+    }
+  }
+
+  if (options.globalOnly && options.projectOnly) {
+    throw new Error("Use either --global or --project, not both.");
+  }
+
+  return options;
+}
+
+function printVersion(options) {
+  const lines = [];
+  if (!options.projectOnly) {
+    lines.push(`cli: ${PACKAGE_VERSION}`);
+  }
+  if (!options.globalOnly) {
+    const projectInfo = getProjectVersionInfo({ targetDir: options.targetDir });
+    if (projectInfo.status === "managed") {
+      lines.push(`project: ${projectInfo.package_version}`);
+      lines.push(`platform: ${projectInfo.platform}`);
+      lines.push(`language: ${projectInfo.lang}`);
+    } else if (projectInfo.status === "legacy") {
+      lines.push("project: legacy");
+      lines.push(`platform: ${projectInfo.platform}`);
+      lines.push(`language: ${projectInfo.lang}`);
+    } else {
+      lines.push("project: not initialized");
+    }
+  }
+  console.log(lines.join("\n"));
+}
+
 function shouldUseInteractiveInit(options) {
   if (options.lang && options.platform) {
     return false;
@@ -140,10 +194,15 @@ async function main() {
     return;
   }
 
-  if (!["init", "install", "update"].includes(command)) {
+  if (!["init", "install", "update", "version"].includes(command)) {
     throw new Error(`Unknown command: ${command}`);
   }
 
+  if (command === "version") {
+    printVersion(parseVersionArgs(rest));
+    return;
+  }
+
   if (command === "update") {
     const options = parseUpdateArgs(rest);
     if (options.allProjects) {
@@ -162,6 +221,9 @@ async function main() {
     console.log(`superlab updated in ${options.targetDir}`);
     console.log(`platform: ${metadata.platform}`);
     console.log(`language: ${metadata.lang}`);
+    if (metadata.migration) {
+      console.log(`migration: ${metadata.migration}`);
+    }
     return;
   }
 
@@ -170,7 +232,7 @@ async function main() {
   if (options.platform === "all") {
     options.platform = "both";
   }
-  installSuperlab(options);
+  installSuperlab({ ...options, registerProject: true });
   console.log(`superlab installed into ${options.targetDir}`);
   console.log(`platform: ${options.platform}`);
   console.log(`language: ${options.lang}`);

package/lib/install.cjs

@@ -137,6 +137,76 @@ function readProjectInstallMetadata(targetDir) {
   return JSON.parse(fs.readFileSync(filePath, "utf8"));
 }
 
+function detectLegacyPlatform(targetDir) {
+  const hasCodex =
+    fs.existsSync(path.join(targetDir, ".codex", "prompts")) ||
+    fs.existsSync(path.join(targetDir, ".codex", "skills", "lab"));
+  const hasClaude =
+    fs.existsSync(path.join(targetDir, ".claude", "commands", "lab")) ||
+    fs.existsSync(path.join(targetDir, ".claude", "skills", "lab"));
+
+  if (hasCodex && hasClaude) {
+    return "both";
+  }
+  if (hasCodex) {
+    return "codex";
+  }
+  if (hasClaude) {
+    return "claude";
+  }
+  return null;
+}
+
+function looksChinese(text) {
+  return /[\u3400-\u9fff]/.test(text);
+}
+
+function detectLegacyLanguage(targetDir) {
+  const workflowConfigPath = path.join(targetDir, ".superlab", "config", "workflow.json");
+  if (fs.existsSync(workflowConfigPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(workflowConfigPath, "utf8"));
+      if (config.workflow_language === "zh" || config.workflow_language === "en") {
+        return config.workflow_language;
+      }
+    } catch {
+      // Fall through to file-content heuristics.
+    }
+  }
+
+  const probeFiles = [
+    path.join(targetDir, ".codex", "prompts", "lab-idea.md"),
+    path.join(targetDir, ".claude", "commands", "lab", "idea.md"),
+    path.join(targetDir, ".superlab", "templates", "idea.md"),
+  ];
+
+  for (const probeFile of probeFiles) {
+    if (!fs.existsSync(probeFile)) {
+      continue;
+    }
+    const content = fs.readFileSync(probeFile, "utf8");
+    return looksChinese(content) ? "zh" : "en";
+  }
+
+  return "en";
+}
+
+function detectLegacyInstallMetadata(targetDir) {
+  const platform = detectLegacyPlatform(targetDir);
+  if (!platform) {
+    return null;
+  }
+
+  return {
+    target_dir: path.resolve(targetDir),
+    platform,
+    lang: detectLegacyLanguage(targetDir),
+    package_version: "legacy",
+    updated_at: null,
+    legacy: true,
+  };
+}
+
 function readRegistry({ env = process.env } = {}) {
   const filePath = registryFilePath({ env });
   if (!fs.existsSync(filePath)) {
@@ -170,6 +240,16 @@ function registerProjectInstall(targetDir, metadata, { env = process.env } = {})
   writeRegistry(registry, { env });
 }
 
+function isTemporaryTestPath(targetDir) {
+  const resolvedTarget = path.resolve(targetDir);
+  const tmpRoot = path.resolve(os.tmpdir());
+  const relativeToTmp = path.relative(tmpRoot, resolvedTarget);
+  if (relativeToTmp.startsWith("..") || path.isAbsolute(relativeToTmp)) {
+    return false;
+  }
+  return path.basename(resolvedTarget).startsWith("superlab-");
+}
+
 function detectLanguage({ explicitLang, env = process.env } = {}) {
   if (explicitLang) {
     if (!["en", "zh"].includes(explicitLang)) {
@@ -243,7 +323,14 @@ function localizeInstalledAssets(targetDir, lang) {
   }
 }
 
-function installSuperlab({ targetDir, platform = "both", force = false, lang, env = process.env } = {}) {
+function installSuperlab({
+  targetDir,
+  platform = "both",
+  force = false,
+  lang,
+  env = process.env,
+  registerProject = false,
+} = {}) {
   const groups = [];
   if (platform === "codex" || platform === "both") {
     groups.push(...ASSET_GROUPS.codex);
@@ -267,46 +354,112 @@ function installSuperlab({ targetDir, platform = "both", force = false, lang, en
     updated_at: new Date().toISOString(),
   };
   writeProjectInstallMetadata(targetDir, metadata);
-  registerProjectInstall(targetDir, metadata, { env });
+  if (registerProject) {
+    registerProjectInstall(targetDir, metadata, { env });
+  }
+  return metadata;
 }
 
 function updateSuperlabProject({ targetDir, env = process.env } = {}) {
-  const metadata = readProjectInstallMetadata(targetDir);
-  installSuperlab({
+  let metadata;
+  let migratedLegacy = false;
+  try {
+    metadata = readProjectInstallMetadata(targetDir);
+  } catch (error) {
+    metadata = detectLegacyInstallMetadata(targetDir);
+    if (!metadata) {
+      throw error;
+    }
+    migratedLegacy = true;
+  }
+
+  const installedMetadata = installSuperlab({
     targetDir,
     platform: metadata.platform,
     lang: metadata.lang,
     force: true,
     env,
+    registerProject: true,
   });
-  return metadata;
+  if (migratedLegacy) {
+    installedMetadata.migration = "legacy project metadata reconstructed";
+  }
+  return installedMetadata;
 }
 
 function updateAllProjects({ env = process.env } = {}) {
   const registry = readRegistry({ env });
   const updated = [];
   const skipped = [];
+  const retained = [];
 
   for (const project of registry.projects) {
     try {
+      if (isTemporaryTestPath(project.path)) {
+        skipped.push({ path: project.path, reason: "temporary path pruned from registry" });
+        continue;
+      }
       if (!fs.existsSync(project.path)) {
         skipped.push({ path: project.path, reason: "missing project path" });
         continue;
       }
-      updateSuperlabProject({ targetDir: project.path, env });
+      const metadata = updateSuperlabProject({ targetDir: project.path, env });
       updated.push(project.path);
+      retained.push({
+        path: path.resolve(project.path),
+        platform: metadata.platform,
+        lang: metadata.lang,
+        package_version: metadata.package_version,
+        updated_at: metadata.updated_at,
+      });
     } catch (error) {
       skipped.push({ path: project.path, reason: error.message });
+      if (fs.existsSync(project.path)) {
+        retained.push(project);
+      }
     }
   }
 
+  writeRegistry({ projects: retained }, { env });
   return { updated, skipped };
 }
 
+function getProjectVersionInfo({ targetDir } = {}) {
+  try {
+    const metadata = readProjectInstallMetadata(targetDir);
+    return {
+      status: "managed",
+      package_version: metadata.package_version,
+      platform: metadata.platform,
+      lang: metadata.lang,
+    };
+  } catch {
+    const legacyMetadata = detectLegacyInstallMetadata(targetDir);
+    if (!legacyMetadata) {
+      return {
+        status: "missing",
+        package_version: null,
+        platform: null,
+        lang: null,
+      };
+    }
+    return {
+      status: "legacy",
+      package_version: "legacy",
+      platform: legacyMetadata.platform,
+      lang: legacyMetadata.lang,
+    };
+  }
+}
+
 module.exports = {
+  PACKAGE_VERSION,
   detectLanguage,
+  detectLegacyInstallMetadata,
   installSuperlab,
   installMetadataPath,
+  isTemporaryTestPath,
+  getProjectVersionInfo,
   readProjectInstallMetadata,
   registryFilePath,
   readRegistry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlab",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Strict /lab research workflow installer for Codex and Claude",
   "keywords": [
     "codex",