team-skills 1.0.0

package/src/commands/update.js

@@ -0,0 +1,118 @@
+import { join } from 'node:path';
+import { existsSync, readdirSync, statSync, copyFileSync as fsCopyFile } from 'node:fs';
+import { LOCAL_INSTALL_DIR, PACKAGE_ROOT, SKILLS_DIR, HOOKS_DIR, COMMANDS_DIR } from '../lib/constants.js';
+import { computeDirectoryHashes, computeFileHash, ensureDir } from '../lib/fs-utils.js';
+import { readManifest, writeManifest, createManifest, getPackageVersion } from '../lib/manifest.js';
+import * as log from '../lib/logger.js';
+import { dirname } from 'node:path';
+
+export function registerUpdate(program) {
+  program
+    .command('update')
+    .description('Update previously init\'d skills to latest version')
+    .argument('[dir]', 'Project directory', '.')
+    .option('--force', 'Overwrite locally modified files (creates .bak backup)', false)
+    .option('--dry-run', 'Show what would change', false)
+    .action(runUpdate);
+}
+
+function runUpdate(dir, opts) {
+  const { force, dryRun } = opts;
+  const installDir = join(dir, LOCAL_INSTALL_DIR);
+  const manifest = readManifest(installDir);
+
+  if (!manifest) {
+    log.error(`未找到 ${installDir}/manifest.json。请先运行 team-skills init。`);
+    process.exit(1);
+  }
+
+  const currentVersion = getPackageVersion();
+  log.info(`已安装版本: ${manifest.version} | 最新版本: ${currentVersion}`);
+
+  const tag = dryRun ? '[dry-run] ' : '';
+  const sourceMap = buildSourceMap();
+
+  let updated = 0;
+  let skipped = 0;
+  let added = 0;
+
+  log.heading('检查文件更新');
+
+  for (const [relPath, sourceFullPath] of Object.entries(sourceMap)) {
+    const installedPath = join(installDir, relPath);
+    const sourceHash = computeFileHash(sourceFullPath);
+
+    if (!existsSync(installedPath)) {
+      if (!dryRun) {
+        ensureDir(dirname(installedPath));
+        fsCopyFile(sourceFullPath, installedPath);
+      }
+      log.success(`${tag}新增: ${relPath}`);
+      added++;
+      continue;
+    }
+
+    const installedHash = computeFileHash(installedPath);
+    if (installedHash === sourceHash) continue;
+
+    const manifestHash = manifest.files[relPath];
+    if (manifestHash && installedHash !== manifestHash && !force) {
+      log.warn(`跳过: ${relPath}（本地已修改，使用 --force 覆盖）`);
+      skipped++;
+      continue;
+    }
+
+    if (!dryRun) {
+      if (force && manifestHash && installedHash !== manifestHash) {
+        fsCopyFile(installedPath, installedPath + '.bak');
+        log.info(`备份: ${relPath}.bak`);
+      }
+      fsCopyFile(sourceFullPath, installedPath);
+    }
+    log.success(`${tag}更新: ${relPath}`);
+    updated++;
+  }
+
+  for (const relPath of Object.keys(manifest.files)) {
+    if (!sourceMap[relPath]) {
+      log.warn(`源文件已删除: ${relPath}（如不再需要请手动删除）`);
+    }
+  }
+
+  if (!dryRun) {
+    const newHashes = computeDirectoryHashes(installDir);
+    delete newHashes['manifest.json'];
+    const newManifest = createManifest(currentVersion, newHashes);
+    writeManifest(installDir, newManifest);
+  }
+
+  log.done(`更新完成${dryRun ? ' (dry-run)' : ''}！更新 ${updated}，新增 ${added}，跳过 ${skipped}。`);
+}
+
+function buildSourceMap() {
+  const map = {};
+
+  const skillsDir = join(PACKAGE_ROOT, SKILLS_DIR);
+  if (existsSync(skillsDir)) scanRecursive(skillsDir, 'skills', map);
+
+  const hooksDir = join(PACKAGE_ROOT, HOOKS_DIR);
+  if (existsSync(hooksDir)) scanRecursive(hooksDir, 'hooks', map);
+
+  const cmdsDir = join(PACKAGE_ROOT, COMMANDS_DIR);
+  if (existsSync(cmdsDir)) scanRecursive(cmdsDir, 'commands', map);
+
+  return map;
+}
+
+function scanRecursive(baseDir, prefix, map) {
+  const entries = readdirSync(baseDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(baseDir, entry.name);
+    const relPath = `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      scanRecursive(fullPath, relPath, map);
+    } else {
+      map[relPath] = fullPath;
+    }
+  }
+}

package/src/lib/constants.js

@@ -0,0 +1,17 @@
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const PACKAGE_ROOT = join(__dirname, '..', '..');
+export const DEFAULT_SKILLS_TARGET = join(homedir(), '.agents', 'skills');
+export const DEFAULT_COMMANDS_TARGET = join(homedir(), '.claude', 'commands');
+export const CURSOR_HOOKS_DIR = join(homedir(), '.cursor', 'hooks');
+export const CLAUDE_HOOKS_DIR = join(homedir(), '.claude', 'hooks');
+export const LOCAL_INSTALL_DIR = '.team-skills';
+export const MANIFEST_FILE = 'manifest.json';
+export const SKILLS_DIR = 'skills';
+export const HOOKS_DIR = 'hooks';
+export const COMMANDS_DIR = join('.claude', 'commands');

package/src/lib/fs-utils.js

@@ -0,0 +1,117 @@
+import {
+  mkdirSync, symlinkSync, unlinkSync, readlinkSync,
+  lstatSync, existsSync, readdirSync, statSync,
+  copyFileSync, readFileSync, chmodSync, rmSync,
+} from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+
+export function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+
+export function isSymlink(p) {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+export function isSymlinkTo(p, target) {
+  try {
+    return lstatSync(p).isSymbolicLink() && readlinkSync(p) === target;
+  } catch {
+    return false;
+  }
+}
+
+export function createSymlinkSafe(source, target, { force = false, dryRun = false } = {}) {
+  if (dryRun) return 'dry-run';
+
+  if (isSymlink(target)) {
+    if (readlinkSync(target) === source) return 'exists';
+    if (!force) return 'conflict';
+    unlinkSync(target);
+  } else if (existsSync(target)) {
+    if (!force) return 'conflict';
+    unlinkSync(target);
+  }
+
+  ensureDir(dirname(target));
+
+  const isDir = statSync(source).isDirectory();
+  symlinkSync(source, target, isDir ? 'dir' : 'file');
+  return 'created';
+}
+
+export function removeSymlinkSafe(target, expectedSource) {
+  if (!isSymlink(target)) return 'not-found';
+
+  if (expectedSource) {
+    const actual = readlinkSync(target);
+    if (actual !== expectedSource) return 'foreign';
+  }
+
+  unlinkSync(target);
+  return 'removed';
+}
+
+export function computeFileHash(filePath) {
+  const content = readFileSync(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}
+
+export function copyRecursive(source, target) {
+  ensureDir(target);
+  const entries = readdirSync(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(source, entry.name);
+    const dstPath = join(target, entry.name);
+
+    if (entry.isDirectory()) {
+      copyRecursive(srcPath, dstPath);
+    } else {
+      copyFileSync(srcPath, dstPath);
+      try {
+        const srcStat = statSync(srcPath);
+        chmodSync(dstPath, srcStat.mode);
+      } catch {
+        // best-effort permission copy
+      }
+    }
+  }
+}
+
+export function computeDirectoryHashes(dirPath, prefix = '') {
+  const hashes = {};
+  if (!existsSync(dirPath)) return hashes;
+
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name);
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      Object.assign(hashes, computeDirectoryHashes(fullPath, relPath));
+    } else {
+      hashes[relPath] = computeFileHash(fullPath);
+    }
+  }
+
+  return hashes;
+}
+
+export function rmdirIfEmpty(dir) {
+  try {
+    const entries = readdirSync(dir);
+    if (entries.length === 0) {
+      rmSync(dir);
+      return true;
+    }
+  } catch {
+    // ignore
+  }
+  return false;
+}

package/src/lib/inventory.js

@@ -0,0 +1,64 @@
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { PACKAGE_ROOT, SKILLS_DIR, HOOKS_DIR, COMMANDS_DIR } from './constants.js';
+
+export function discoverSkills(root = PACKAGE_ROOT) {
+  const skillsDir = join(root, SKILLS_DIR);
+  if (!existsSync(skillsDir)) return [];
+
+  return readdirSync(skillsDir)
+    .filter(name => {
+      if (name.startsWith('_') || name === 'CLAUDE.md') return false;
+      const full = join(skillsDir, name);
+      return statSync(full).isDirectory();
+    })
+    .map(name => ({
+      name,
+      path: join(skillsDir, name),
+      hasReferences: existsSync(join(skillsDir, name, 'references')),
+    }));
+}
+
+export function discoverSharedRules(root = PACKAGE_ROOT) {
+  const rulesDir = join(root, SKILLS_DIR, '_team-rules');
+  if (!existsSync(rulesDir)) return [];
+
+  return readdirSync(rulesDir)
+    .filter(name => name.endsWith('.md'))
+    .map(name => ({
+      name,
+      path: join(rulesDir, name),
+    }));
+}
+
+export function discoverCommands(root = PACKAGE_ROOT) {
+  const cmdDir = join(root, COMMANDS_DIR);
+  if (!existsSync(cmdDir)) return [];
+
+  return readdirSync(cmdDir)
+    .filter(name => name.endsWith('.md'))
+    .map(name => ({
+      name: basename(name, '.md'),
+      filename: name,
+      path: join(cmdDir, name),
+    }));
+}
+
+export function discoverHooks(root = PACKAGE_ROOT) {
+  const hooksDir = join(root, HOOKS_DIR);
+  const files = [];
+
+  for (const name of ['hooks.json', 'session-start']) {
+    const full = join(hooksDir, name);
+    if (existsSync(full)) {
+      files.push({ name, path: full });
+    }
+  }
+
+  return files;
+}
+
+export function discoverSkillsModuleClaude(root = PACKAGE_ROOT) {
+  const p = join(root, SKILLS_DIR, 'CLAUDE.md');
+  return existsSync(p) ? p : null;
+}

package/src/lib/logger.js

@@ -0,0 +1,34 @@
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BLUE = '\x1b[34m';
+const GRAY = '\x1b[90m';
+
+export function success(msg) {
+  console.log(`${GREEN}✅${RESET} ${msg}`);
+}
+
+export function warn(msg) {
+  console.log(`${YELLOW}⚠️${RESET}  ${msg}`);
+}
+
+export function error(msg) {
+  console.error(`${RED}❌${RESET} ${msg}`);
+}
+
+export function info(msg) {
+  console.log(`${BLUE}ℹ${RESET}  ${msg}`);
+}
+
+export function skip(msg) {
+  console.log(`${GRAY}⏭${RESET}  ${msg}`);
+}
+
+export function heading(msg) {
+  console.log(`\n${BLUE}===${RESET} ${msg} ${BLUE}===${RESET}`);
+}
+
+export function done(msg) {
+  console.log(`\n${GREEN}🎉${RESET} ${msg}`);
+}

package/src/lib/manifest.js

@@ -0,0 +1,45 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { MANIFEST_FILE, PACKAGE_ROOT } from './constants.js';
+
+export function readManifest(dir) {
+  const p = join(dir, MANIFEST_FILE);
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeManifest(dir, data) {
+  const p = join(dir, MANIFEST_FILE);
+  writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+export function createManifest(packageVersion, fileHashes) {
+  return {
+    version: packageVersion,
+    installedAt: new Date().toISOString(),
+    sourceCommit: getSourceCommit(),
+    files: fileHashes,
+  };
+}
+
+function getSourceCommit() {
+  try {
+    return execSync('git rev-parse --short HEAD', {
+      cwd: PACKAGE_ROOT,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return 'unknown';
+  }
+}
+
+export function getPackageVersion() {
+  const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+  return pkg.version;
+}