superlab 0.1.4 → 0.1.6

package/README.md

@@ -68,6 +68,28 @@ superlab init --all
 
 `--all` is an alias for `--platform both`. Use `--force` if you need to overwrite existing files.
 
+## Update
+
+Refresh the current project:
+
+```bash
+superlab update
+```
+
+Refresh a specific project:
+
+```bash
+superlab update --target /path/to/project
+```
+
+Refresh every registered project initialized from this user account:
+
+```bash
+superlab update --all-projects
+```
+
+`superlab init` writes `.superlab/install.json` inside each project and registers the project in the user-level registry so `update --all-projects` knows what to refresh.
+
 ## Language
 
 The installer chooses the display language from your system locale. If it detects Chinese locale values, it installs Chinese-facing command and skill text; otherwise it falls back to English.

package/README.zh-CN.md

@@ -66,6 +66,28 @@ superlab init --all
 
 `--all` 是 `--platform both` 的别名。如果目标目录已有同名文件，可以加 `--force` 覆盖。
 
+## 更新
+
+刷新当前项目：
+
+```bash
+superlab update
+```
+
+刷新指定项目：
+
+```bash
+superlab update --target /path/to/project
+```
+
+刷新当前用户登记过的所有项目：
+
+```bash
+superlab update --all-projects
+```
+
+`superlab init` 会在项目内写入 `.superlab/install.json`，并在用户级 registry 里登记项目路径，所以 `update --all-projects` 才知道要刷新哪些项目。
+
 ## 语言
 
 安装器会根据系统 locale 自动猜测展示语言。检测到中文 locale 时会安装中文命令和技能文案；否则默认安装英文文案。

package/bin/superlab.cjs

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 
 const path = require("node:path");
-const { detectLanguage, installSuperlab } = require("../lib/install.cjs");
+const {
+  PACKAGE_VERSION,
+  detectLanguage,
+  getProjectVersionInfo,
+  installSuperlab,
+  updateAllProjects,
+  updateSuperlabProject,
+} = require("../lib/install.cjs");
 const { promptSelect } = require("../lib/init_tui.cjs");
 
 function printHelp() {
@@ -10,10 +17,15 @@ function printHelp() {
 Usage:
   superlab init [--target <dir>] [--platform codex|claude|both|all] [--lang en|zh] [--force]
   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
 `);
 }
@@ -56,6 +68,81 @@ function parseInstallArgs(argv) {
   return options;
 }
 
+function parseUpdateArgs(argv) {
+  const options = {
+    targetDir: process.cwd(),
+    allProjects: 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 === "--all-projects") {
+      options.allProjects = true;
+    } else {
+      throw new Error(`Unknown option: ${value}`);
+    }
+  }
+
+  if (options.allProjects && argv.includes("--target")) {
+    throw new Error("Use either --target or --all-projects, not both.");
+  }
+
+  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;
@@ -107,16 +194,45 @@ async function main() {
     return;
   }
 
-  if (!["init", "install"].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) {
+      const result = updateAllProjects();
+      console.log(`updated projects: ${result.updated.length}`);
+      for (const project of result.updated) {
+        console.log(`updated: ${project}`);
+      }
+      for (const project of result.skipped) {
+        console.log(`skipped: ${project.path} (${project.reason})`);
+      }
+      return;
+    }
+
+    const metadata = updateSuperlabProject({ targetDir: options.targetDir });
+    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;
+  }
+
   const parsedOptions = parseInstallArgs(rest);
   const options = await resolveInitOptions(parsedOptions);
   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

@@ -1,8 +1,10 @@
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 const { getLocalizedContent } = require("./i18n.cjs");
 
 const REPO_ROOT = path.resolve(__dirname, "..");
+const PACKAGE_VERSION = require(path.join(REPO_ROOT, "package.json")).version;
 
 const ASSET_GROUPS = {
   codex: [
@@ -102,6 +104,152 @@ function chmodScripts(targetDir) {
   }
 }
 
+function superlabHomeDir({ env = process.env } = {}) {
+  if (env.SUPERLAB_HOME) {
+    return env.SUPERLAB_HOME;
+  }
+  return path.join(env.HOME || os.homedir(), ".superlab");
+}
+
+function registryFilePath({ env = process.env } = {}) {
+  return path.join(superlabHomeDir({ env }), "registry.json");
+}
+
+function installMetadataPath(targetDir) {
+  return path.join(targetDir, ".superlab", "install.json");
+}
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function writeProjectInstallMetadata(targetDir, metadata) {
+  const filePath = installMetadataPath(targetDir);
+  ensureParentDir(filePath);
+  fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2) + "\n");
+}
+
+function readProjectInstallMetadata(targetDir) {
+  const filePath = installMetadataPath(targetDir);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`No superlab installation metadata found in ${targetDir}. Run 'superlab init' first.`);
+  }
+  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)) {
+    return { projects: [] };
+  }
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeRegistry(registry, { env = process.env } = {}) {
+  const filePath = registryFilePath({ env });
+  ensureParentDir(filePath);
+  fs.writeFileSync(filePath, JSON.stringify(registry, null, 2) + "\n");
+}
+
+function registerProjectInstall(targetDir, metadata, { env = process.env } = {}) {
+  const registry = readRegistry({ env });
+  const normalizedTarget = path.resolve(targetDir);
+  const entry = {
+    path: normalizedTarget,
+    platform: metadata.platform,
+    lang: metadata.lang,
+    package_version: metadata.package_version,
+    updated_at: metadata.updated_at,
+  };
+  const existingIndex = registry.projects.findIndex((project) => project.path === normalizedTarget);
+  if (existingIndex >= 0) {
+    registry.projects[existingIndex] = entry;
+  } else {
+    registry.projects.push(entry);
+  }
+  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)) {
@@ -175,7 +323,14 @@ function localizeInstalledAssets(targetDir, lang) {
   }
 }
 
-function installSuperlab({ targetDir, platform = "both", force = false, lang } = {}) {
+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);
@@ -188,11 +343,126 @@ function installSuperlab({ targetDir, platform = "both", force = false, lang } =
   for (const asset of groups) {
     copyDirectory(asset.from, path.join(targetDir, asset.to), force);
   }
-  localizeInstalledAssets(targetDir, detectLanguage({ explicitLang: lang }));
+  const resolvedLang = detectLanguage({ explicitLang: lang, env });
+  localizeInstalledAssets(targetDir, resolvedLang);
   chmodScripts(targetDir);
+  const metadata = {
+    target_dir: path.resolve(targetDir),
+    platform,
+    lang: resolvedLang,
+    package_version: PACKAGE_VERSION,
+    updated_at: new Date().toISOString(),
+  };
+  writeProjectInstallMetadata(targetDir, metadata);
+  if (registerProject) {
+    registerProjectInstall(targetDir, metadata, { env });
+  }
+  return metadata;
+}
+
+function updateSuperlabProject({ targetDir, env = process.env } = {}) {
+  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,
+  });
+  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;
+      }
+      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,
+  updateAllProjects,
+  updateSuperlabProject,
 };

package/package.json

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