teamix-evo 0.5.0 → 0.6.0

package/dist/core/index.js

@@ -517,9 +517,11 @@ function makeMirrorRecord(skill, targetAbs, content, ide, scope, rel2) {
 }
 async function updateSkills(options) {
   const { manifest, ides, scope, projectRoot } = options;
+  const idFilter = options.onlyIds ? new Set(options.onlyIds) : null;
   const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
   const updated = [];
   for (const skill of manifest.skills) {
+    if (idFilter && !idFilter.has(skill.id)) continue;
     const skillIdes = skill.ides.filter((i) => ides.includes(i));
     if (skillIdes.length === 0) continue;
     const sourceRecords = await rewriteSkillSource(
@@ -721,11 +723,73 @@ async function ensureMcpJson(projectRoot) {
 // src/core/skills-add.ts
 var DEFAULT_SKILLS_PACKAGE = "@teamix-evo/skills";
 var FLAT_VARIANT = "_flat";
+async function runSkillsInit(options) {
+  const { projectRoot } = options;
+  const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE;
+  const ides = [...options.ides];
+  const scope = options.scope;
+  if (ides.length === 0) {
+    throw new Error("At least one IDE must be selected.");
+  }
+  await ensureTeamixDir(projectRoot);
+  const existingConfig = await readProjectConfig(projectRoot);
+  const existingSkillsCfg = existingConfig?.packages?.skills;
+  const { manifest, data, packageRoot } = await loadSkillsData(packageName);
+  const currentTokensVariant = await readTokensVariant(projectRoot);
+  const existing = await readExistingState(projectRoot, packageName);
+  const candidateIds = manifest.skills.filter((s) => {
+    const effectiveScope = s.scope ?? "project";
+    if (effectiveScope !== scope) {
+      logger.debug(
+        `Skipping skill "${s.id}" (scope=${effectiveScope}): current install scope is "${scope}". Use \`skills add ${s.id} --scope ${effectiveScope}\` to install.`
+      );
+      return false;
+    }
+    if (!s.variant) return true;
+    if (!currentTokensVariant) {
+      logger.debug(
+        `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no tokens variant installed; will be picked up when "tokens init" runs.`
+      );
+      return false;
+    }
+    if (s.variant !== currentTokensVariant) {
+      logger.debug(
+        `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current tokens variant is "${currentTokensVariant}".`
+      );
+      return false;
+    }
+    return true;
+  }).map((s) => s.id);
+  const skippedSkillIds = candidateIds.filter(
+    (id) => existing.skillIds.has(id)
+  );
+  const onlyIds = candidateIds.filter((id) => !existing.skillIds.has(id));
+  if (existingSkillsCfg && onlyIds.length === 0) {
+    return { status: "already-initialized" };
+  }
+  return finalizeSkillsInstall({
+    projectRoot,
+    packageName,
+    ideIdent: options.ide ?? "qoder",
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  });
+}
 async function runSkillsAdd(options) {
+  if (!options.names || options.names.length === 0) {
+    throw new Error(
+      "runSkillsAdd requires at least one skill id. Use runSkillsInit() for bulk install."
+    );
+  }
   const { projectRoot, names: requestedNames } = options;
   const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE;
-  const ideIdent = options.ide ?? "qoder";
-  const isIncremental = !!requestedNames && requestedNames.length > 0;
   await ensureTeamixDir(projectRoot);
   const existingConfig = await readProjectConfig(projectRoot);
   const existingSkillsCfg = existingConfig?.packages?.skills;
@@ -738,57 +802,27 @@ async function runSkillsAdd(options) {
     throw new Error("Scope must be specified (project | global).");
   }
   const { manifest, data, packageRoot } = await loadSkillsData(packageName);
-  const currentTokensVariant = await readTokensVariant(projectRoot);
-  if (isIncremental) {
-    const known = new Set(manifest.skills.map((s) => s.id));
-    const unknown = requestedNames.filter((n) => !known.has(n));
-    if (unknown.length > 0) {
-      const available = [...known].join(", ");
-      throw new Error(
-        `Unknown skill id(s): ${unknown.join(", ")}. Available: ${available || "(none)"}.`
+  const known = new Set(manifest.skills.map((s) => s.id));
+  const unknown = requestedNames.filter((n) => !known.has(n));
+  if (unknown.length > 0) {
+    const available = [...known].join(", ");
+    throw new Error(
+      `Unknown skill id(s): ${unknown.join(", ")}. Available: ${available || "(none)"}.`
+    );
+  }
+  for (const s of manifest.skills) {
+    if (requestedNames.includes(s.id) && s.scope && s.scope !== scope) {
+      logger.warn(
+        `"${s.id}" \u63A8\u8350 ${s.scope} scope \u5B89\u88C5\u3002\u5F53\u524D\u4EE5 ${scope} scope \u5F3A\u5236\u5B89\u88C5,\u53EF\u80FD\u4E0E\u53E6\u4E00 scope \u7684\u526F\u672C\u51B2\u7A81\u3002\u5EFA\u8BAE\u6539\u7528 \`skills add ${s.id} --scope ${s.scope}\`\u3002`
       );
     }
   }
-  const existingInstalled = await readInstalledManifest(projectRoot);
-  const existingPkg = existingInstalled?.installed.find(
-    (p) => p.package === packageName
+  const existing = await readExistingState(projectRoot, packageName);
+  const skippedSkillIds = requestedNames.filter(
+    (n) => existing.skillIds.has(n)
   );
-  const existingLock = await readSkillsLock(projectRoot);
-  const existingSkillIds = /* @__PURE__ */ new Set([
-    ...Object.keys(existingLock?.skills ?? {}),
-    // Legacy fallback: pre-ADR-0013 installs only had manifest.json. Derive
-    // skill ids by stripping the trailing :source / :sub-file suffix.
-    ...(existingPkg?.resources ?? []).map((r) => r.id.split(":")[0])
-  ]);
-  let onlyIds;
-  let skippedSkillIds;
-  if (isIncremental) {
-    skippedSkillIds = requestedNames.filter((n) => existingSkillIds.has(n));
-    onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
-  } else {
-    const candidateIds = manifest.skills.filter((s) => {
-      if (!s.variant) return true;
-      if (!currentTokensVariant) {
-        logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no tokens variant installed; will be picked up when "tokens init" runs.`
-        );
-        return false;
-      }
-      if (s.variant !== currentTokensVariant) {
-        logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current tokens variant is "${currentTokensVariant}".`
-        );
-        return false;
-      }
-      return true;
-    }).map((s) => s.id);
-    skippedSkillIds = candidateIds.filter((id) => existingSkillIds.has(id));
-    onlyIds = candidateIds.filter((id) => !existingSkillIds.has(id));
-  }
-  if (!isIncremental && existingSkillsCfg && onlyIds.length === 0) {
-    return { status: "already-added" };
-  }
-  if (isIncremental && onlyIds.length === 0) {
+  const onlyIds = requestedNames.filter((n) => !existing.skillIds.has(n));
+  if (onlyIds.length === 0) {
     return {
       status: "installed",
       packageName,
@@ -802,6 +836,48 @@ async function runSkillsAdd(options) {
       skippedSkillIds
     };
   }
+  return finalizeSkillsInstall({
+    projectRoot,
+    packageName,
+    ideIdent: options.ide ?? "qoder",
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  });
+}
+async function readExistingState(projectRoot, packageName) {
+  const installed = await readInstalledManifest(projectRoot);
+  const pkg = installed?.installed.find((p) => p.package === packageName);
+  const lock = await readSkillsLock(projectRoot);
+  const skillIds = /* @__PURE__ */ new Set([
+    ...Object.keys(lock?.skills ?? {}),
+    // Legacy fallback: pre-ADR-0013 installs only had manifest.json. Derive
+    // skill ids by stripping the trailing :source / :sub-file suffix.
+    ...(pkg?.resources ?? []).map((r) => r.id.split(":")[0] ?? r.id)
+  ]);
+  return { installed, pkg, lock, skillIds };
+}
+async function finalizeSkillsInstall(args) {
+  const {
+    projectRoot,
+    packageName,
+    ideIdent,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  } = args;
   const result = await installSkills({
     projectRoot,
     manifest,
@@ -825,7 +901,7 @@ async function runSkillsAdd(options) {
   };
   await writeProjectConfig(projectRoot, config);
   const installedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const installedManifest = existingInstalled ?? {
+  const installedManifest = existing.installed ?? {
     schemaVersion: 1,
     installed: []
   };
@@ -833,7 +909,7 @@ async function runSkillsAdd(options) {
     (p) => p.package === packageName
   );
   const mergedResources = mergeInstalledResources(
-    existingPkg?.resources ?? [],
+    existing.pkg?.resources ?? [],
     result.resources
   );
   const entry = {
@@ -846,7 +922,7 @@ async function runSkillsAdd(options) {
   if (idx >= 0) installedManifest.installed[idx] = entry;
   else installedManifest.installed.push(entry);
   await writeInstalledManifest(projectRoot, installedManifest);
-  const lock = existingLock ?? {
+  const lock = existing.lock ?? {
     schemaVersion: 1,
     skills: {}
   };
@@ -1138,6 +1214,176 @@ async function listTokenVariants(packageName = DEFAULT_TOKENS_PACKAGE, packageRo
   };
 }
 
+// src/core/skills-update.ts
+var DEFAULT_SKILLS_PACKAGE3 = "@teamix-evo/skills";
+var FLAT_VARIANT2 = "_flat";
+async function runSkillsUpdate(options) {
+  const { projectRoot, names: requestedNames, dryRun } = options;
+  const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE3;
+  const config = await readProjectConfig(projectRoot);
+  const skillsCfg = config?.packages?.skills;
+  if (!skillsCfg) {
+    return { status: "no-skills" };
+  }
+  const ides = skillsCfg.ides ?? ["qoder", "claude"];
+  const scope = skillsCfg.scope ?? "project";
+  const existingLock = await readSkillsLock(projectRoot);
+  if (!existingLock || Object.keys(existingLock.skills).length === 0) {
+    return { status: "no-skills" };
+  }
+  const { manifest, data, packageRoot } = await loadSkillsData(packageName);
+  const manifestById = new Map(manifest.skills.map((s) => [s.id, s]));
+  const lockIds = Object.keys(existingLock.skills);
+  const requestedSet = requestedNames ? new Set(requestedNames) : null;
+  if (requestedSet) {
+    const unknown = requestedNames.filter(
+      (n) => !lockIds.includes(n) && !manifestById.has(n)
+    );
+    if (unknown.length > 0) {
+      throw new Error(
+        `Unknown skill id(s): ${unknown.join(
+          ", "
+        )}. Available (installed): ${lockIds.join(", ") || "(none)"}.`
+      );
+    }
+  }
+  const targetIds = [];
+  const skippedSkillIds = [];
+  for (const id of lockIds) {
+    if (requestedSet && !requestedSet.has(id)) continue;
+    const entry2 = manifestById.get(id);
+    if (!entry2) {
+      logger.debug(
+        `Skipping "${id}": no longer in upstream manifest. Use \`skills uninstall ${id}\` to remove.`
+      );
+      skippedSkillIds.push(id);
+      continue;
+    }
+    const effectiveScope = entry2.scope ?? "project";
+    if (effectiveScope !== scope) {
+      logger.debug(
+        `Skipping "${id}" (scope=${effectiveScope}): current install scope is "${scope}".`
+      );
+      skippedSkillIds.push(id);
+      continue;
+    }
+    targetIds.push(id);
+  }
+  const allSame = targetIds.every((id) => {
+    const lockVer = existingLock.skills[id].version;
+    const manVer = manifestById.get(id).version;
+    return lockVer === manVer;
+  });
+  if (targetIds.length > 0 && allSame && !dryRun) {
+    return {
+      status: "no-changes",
+      packageName,
+      version: manifest.version,
+      checkedSkillIds: targetIds
+    };
+  }
+  if (dryRun) {
+    const plan = targetIds.map((id) => {
+      const lockVer = existingLock.skills[id].version;
+      const entry2 = manifestById.get(id);
+      const sameVersion = lockVer === entry2.version;
+      return {
+        id,
+        current: lockVer,
+        next: entry2.version,
+        strategy: entry2.updateStrategy ?? "managed",
+        action: sameVersion ? "up-to-date" : "version-bump"
+      };
+    });
+    return {
+      status: "dry-run",
+      packageName,
+      currentVersion: skillsCfg.version,
+      availableVersion: manifest.version,
+      plan
+    };
+  }
+  if (targetIds.length === 0) {
+    return {
+      status: "updated",
+      packageName,
+      version: manifest.version,
+      ides,
+      scope,
+      updatedSkillIds: [],
+      skippedSkillIds,
+      summary: { overwritten: 0, managed: 0, skipped: 0, created: 0 },
+      resources: []
+    };
+  }
+  const result = await updateSkills({
+    projectRoot,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds: targetIds
+  });
+  config.packages.skills = {
+    ...skillsCfg,
+    version: manifest.version
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = await readInstalledManifest(projectRoot) ?? {
+    schemaVersion: 1,
+    installed: []
+  };
+  const idx = installedManifest.installed.findIndex(
+    (p) => p.package === packageName
+  );
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const prior = idx >= 0 ? installedManifest.installed[idx].resources : [];
+  const targetSet = new Set(targetIds);
+  const preserved = prior.filter((r) => {
+    const skillId = r.id.split(":")[0];
+    return skillId ? !targetSet.has(skillId) : true;
+  });
+  const entry = {
+    package: packageName,
+    variant: FLAT_VARIANT2,
+    version: manifest.version,
+    installedAt,
+    resources: [...preserved, ...result.resources]
+  };
+  if (idx >= 0) installedManifest.installed[idx] = entry;
+  else installedManifest.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const lock = {
+    schemaVersion: 1,
+    skills: { ...existingLock.skills }
+  };
+  for (const id of targetIds) {
+    const skillDef = manifestById.get(id);
+    if (!skillDef) continue;
+    const mirroredTo = skillDef.ides.filter((i) => ides.includes(i));
+    lock.skills[id] = {
+      version: skillDef.version,
+      from: packageName,
+      installedAt,
+      scope,
+      mirroredTo
+    };
+  }
+  await writeSkillsLock(projectRoot, lock);
+  return {
+    status: "updated",
+    packageName,
+    version: manifest.version,
+    ides,
+    scope,
+    updatedSkillIds: targetIds,
+    skippedSkillIds,
+    summary: result.summary,
+    resources: result.resources
+  };
+}
+
 // src/core/ui-init.ts
 var DEFAULT_UI_ALIASES = {
   components: "src/components/ui",
@@ -1471,9 +1717,109 @@ async function runUiList(options) {
   };
 }
 
-// src/core/installer.ts
+// src/core/lint-init.ts
 import * as path12 from "path";
-import * as fs9 from "fs/promises";
+import * as fs9 from "fs";
+import { execa } from "execa";
+var ESLINT_CONFIG_CONTENT = `/**
+ * teamix-evo consumer ESLint preset \u2014 9 token-discipline rules.
+ * - Repo-wide: no-color-literal / no-arbitrary-tw-value / no-raw-color-scale /
+ *   no-large-radius / prefer-gap-over-space / no-manual-dark-classnames /
+ *   dialog-must-have-title (all error)
+ * - src/components/ui/** only: no-relative-ui-import / icon-from-lucide (error)
+ *
+ * See ADR 0008 / docs/principles.md \xA7P4.
+ */
+import consumerPreset from '@teamix-evo/eslint-config/presets/consumer';
+
+export default [...consumerPreset];
+`;
+var STYLELINT_CONFIG_CONTENT = `/** @type {import('stylelint').Config} */
+module.exports = {
+  extends: ['@teamix-evo/stylelint-config/presets/consumer'],
+};
+`;
+var ESLINT_DEPS = [
+  "@teamix-evo/eslint-config",
+  "eslint",
+  "@typescript-eslint/parser"
+];
+var STYLELINT_DEPS = ["@teamix-evo/stylelint-config", "stylelint"];
+async function runLintInit(options) {
+  const { projectRoot, skipInstall } = options;
+  const eslintConfigPath = path12.join(projectRoot, "eslint.config.js");
+  const stylelintConfigPath = path12.join(projectRoot, "stylelint.config.cjs");
+  const eslintExists = await fileExists(eslintConfigPath);
+  const stylelintExists = await fileExists(stylelintConfigPath);
+  if (eslintExists && stylelintExists) {
+    return { status: "already-initialized" };
+  }
+  if (!skipInstall) {
+    const depsToInstall = [
+      ...eslintExists ? [] : ESLINT_DEPS,
+      ...stylelintExists ? [] : STYLELINT_DEPS
+    ];
+    if (depsToInstall.length > 0) {
+      const pm = detectPm(projectRoot);
+      const args = pm === "yarn" ? ["add", "--dev", ...depsToInstall] : pm === "pnpm" ? ["add", "-D", ...depsToInstall] : ["install", "--save-dev", ...depsToInstall];
+      logger.info(`Installing lint deps via ${pm}...`);
+      await execa(pm, args, { cwd: projectRoot, stdio: "inherit" });
+    }
+  }
+  let wroteEslint = false;
+  let wroteStylelint = false;
+  if (!eslintExists) {
+    await writeFileSafe(eslintConfigPath, ESLINT_CONFIG_CONTENT);
+    logger.debug(`Wrote eslint.config.js \u2192 ${eslintConfigPath}`);
+    wroteEslint = true;
+  }
+  if (!stylelintExists) {
+    await writeFileSafe(stylelintConfigPath, STYLELINT_CONFIG_CONTENT);
+    logger.debug(`Wrote stylelint.config.cjs \u2192 ${stylelintConfigPath}`);
+    wroteStylelint = true;
+  }
+  await patchPackageJsonScripts(projectRoot);
+  return {
+    status: "installed",
+    eslint: wroteEslint,
+    stylelint: wroteStylelint
+  };
+}
+function detectPm(projectRoot) {
+  if (fs9.existsSync(path12.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs9.existsSync(path12.join(projectRoot, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+async function patchPackageJsonScripts(projectRoot) {
+  const pkgPath = path12.join(projectRoot, "package.json");
+  const raw = await readFileOrNull(pkgPath);
+  if (!raw) return;
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const scripts = pkg.scripts ?? {};
+  let changed = false;
+  if (!scripts.lint) {
+    scripts.lint = "eslint src/";
+    changed = true;
+  }
+  if (!scripts["lint:css"]) {
+    scripts["lint:css"] = "stylelint 'src/**/*.css'";
+    changed = true;
+  }
+  if (changed) {
+    pkg.scripts = scripts;
+    await writeFileSafe(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    logger.debug("Patched package.json scripts with lint / lint:css");
+  }
+}
+
+// src/core/installer.ts
+import * as path13 from "path";
+import * as fs10 from "fs/promises";
 async function installResources(options) {
   const { projectRoot, manifest, data, variantDir, packageRoot } = options;
   const installedResources = [];
@@ -1510,13 +1856,13 @@ async function installSingleResource(resource, projectRoot, data, variantDir, pa
     variantDir,
     packageRoot
   );
-  const targetPath = path12.join(projectRoot, resource.target);
+  const targetPath = path13.join(projectRoot, resource.target);
   let content;
   if (resource.template) {
     const templateContent = await loadTemplateFile(sourcePath);
     content = renderTemplate(templateContent, data);
   } else {
-    content = await fs9.readFile(sourcePath, "utf-8");
+    content = await fs10.readFile(sourcePath, "utf-8");
   }
   await writeFileSafe(targetPath, content);
   const hash = computeHash(content);
@@ -1534,13 +1880,13 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
     variantDir,
     packageRoot
   );
-  const targetDir = path12.join(projectRoot, resource.target);
+  const targetDir = path13.join(projectRoot, resource.target);
   const results = [];
   await ensureDir(targetDir);
   const entries = await walkDir(sourcePath);
   for (const entry of entries) {
-    const relPath = path12.relative(sourcePath, entry);
-    let targetFile = path12.join(targetDir, relPath);
+    const relPath = path13.relative(sourcePath, entry);
+    let targetFile = path13.join(targetDir, relPath);
     if (resource.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
@@ -1549,11 +1895,11 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
       const templateContent = await loadTemplateFile(entry);
       content = renderTemplate(templateContent, data);
     } else {
-      content = await fs9.readFile(entry, "utf-8");
+      content = await fs10.readFile(entry, "utf-8");
     }
     await writeFileSafe(targetFile, content);
     const hash = computeHash(content);
-    const targetRel = path12.relative(projectRoot, targetFile);
+    const targetRel = path13.relative(projectRoot, targetFile);
     results.push({
       id: `${resource.id}:${relPath}`,
       target: targetRel,
@@ -1566,25 +1912,25 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
 }
 
 // src/core/registry-client.ts
-import * as path13 from "path";
-import * as fs10 from "fs/promises";
+import * as path14 from "path";
+import * as fs11 from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { loadVariantManifest } from "@teamix-evo/registry";
 var require5 = createRequire4(import.meta.url);
 function resolvePackageRoot3(packageName) {
   const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
-  return path13.dirname(pkgJsonPath);
+  return path14.dirname(pkgJsonPath);
 }
 async function loadVariantData(packageName, variant) {
   const packageRoot = resolvePackageRoot3(packageName);
-  const variantDir = path13.join(packageRoot, "library", variant);
+  const variantDir = path14.join(packageRoot, "library", variant);
   logger.debug(`Resolved variant dir: ${variantDir}`);
   logger.debug(`Package root: ${packageRoot}`);
   const manifest = await loadVariantManifest(variantDir);
   let data = {};
-  const dataPath = path13.join(variantDir, "_data.json");
+  const dataPath = path14.join(variantDir, "_data.json");
   try {
-    const raw = await fs10.readFile(dataPath, "utf-8");
+    const raw = await fs11.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -1610,7 +1956,10 @@ export {
   readProjectConfig,
   removeSkillFiles,
   removeUiFiles,
+  runLintInit,
   runSkillsAdd,
+  runSkillsInit,
+  runSkillsUpdate,
   runTokensInit,
   runUiAdd,
   runUiInit,