@wang121ye/skillmanager 0.0.1

package/src/lib/config.js

@@ -0,0 +1,75 @@
+const path = require('path');
+const { fileExists, readJson, writeJson } = require('./fs');
+const { getAppPaths } = require('./paths');
+
+function getUserConfigPath() {
+  const p = getAppPaths();
+  return path.join(p.configDir, 'config.json');
+}
+
+async function loadConfig() {
+  const configPath = getUserConfigPath();
+  if (!(await fileExists(configPath))) {
+    const initial = { version: 1, defaultProfile: 'default', remoteProfileUrl: null };
+    await writeJson(configPath, initial);
+    return { configPath, config: initial };
+  }
+  try {
+    const config = await readJson(configPath);
+    return { configPath, config: config || { version: 1, defaultProfile: 'default', remoteProfileUrl: null } };
+  } catch {
+    const fallback = { version: 1, defaultProfile: 'default', remoteProfileUrl: null };
+    await writeJson(configPath, fallback);
+    return { configPath, config: fallback };
+  }
+}
+
+async function setDefaultProfile(name) {
+  const { configPath, config } = await loadConfig();
+  const next = { ...(config || {}), version: 1, defaultProfile: String(name || 'default') };
+  await writeJson(configPath, next);
+  return { configPath, config: next };
+}
+
+async function setRemoteProfileUrl(url) {
+  const { configPath, config } = await loadConfig();
+  const next = { ...(config || {}), version: 1, remoteProfileUrl: url ? String(url) : null };
+  await writeJson(configPath, next);
+  return { configPath, config: next };
+}
+
+function getDefaultProfileFromEnv() {
+  const v = process.env.SKILLMANAGER_PROFILE;
+  return v && String(v).trim() ? String(v).trim() : null;
+}
+
+function getRemoteProfileUrlFromEnv() {
+  const v = process.env.SKILLMANAGER_PROFILE_URL;
+  return v && String(v).trim() ? String(v).trim() : null;
+}
+
+async function getEffectiveDefaultProfile() {
+  const env = getDefaultProfileFromEnv();
+  if (env) return env;
+  const { config } = await loadConfig();
+  const v = config?.defaultProfile;
+  return v && String(v).trim() ? String(v).trim() : 'default';
+}
+
+async function getEffectiveRemoteProfileUrl() {
+  const env = getRemoteProfileUrlFromEnv();
+  if (env) return env;
+  const { config } = await loadConfig();
+  const v = config?.remoteProfileUrl;
+  return v && String(v).trim() ? String(v).trim() : null;
+}
+
+module.exports = {
+  loadConfig,
+  setDefaultProfile,
+  setRemoteProfileUrl,
+  getEffectiveDefaultProfile,
+  getEffectiveRemoteProfileUrl,
+  getUserConfigPath
+};
+

package/src/lib/fs.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+async function ensureDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+async function fileExists(p) {
+  try {
+    await fsp.access(p, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(p) {
+  const raw = await fsp.readFile(p, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function writeJson(p, obj) {
+  await ensureDir(path.dirname(p));
+  await fsp.writeFile(p, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+async function rmDir(p) {
+  await fsp.rm(p, { recursive: true, force: true });
+}
+
+module.exports = { ensureDir, fileExists, readJson, writeJson, rmDir };
+

package/src/lib/git.js

@@ -0,0 +1,57 @@
+const path = require('path');
+const simpleGit = require('simple-git');
+const { ensureDir, fileExists, rmDir } = require('./fs');
+
+function sanitizeId(id) {
+  return String(id).replace(/[^a-zA-Z0-9._-]+/g, '_');
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function ensureRepo({ reposDir, source }) {
+  if (!source?.repo) {
+    throw new Error(`Invalid source repo for ${source?.id || '<unknown>'}`);
+  }
+
+  const repoDir = path.join(reposDir, sanitizeId(source.id));
+  await ensureDir(reposDir);
+
+  const gitDir = path.join(repoDir, '.git');
+  const git = simpleGit();
+
+  if (!(await fileExists(gitDir))) {
+    const cloneArgs = ['--depth', '1', '--single-branch', '--filter=blob:none'];
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        await rmDir(repoDir);
+        await ensureDir(repoDir);
+        await git.clone(source.repo, repoDir, cloneArgs);
+        return repoDir;
+      } catch (err) {
+        await rmDir(repoDir);
+        if (attempt === 3) throw err;
+        await sleep(1000 * attempt);
+      }
+    }
+    return repoDir;
+  }
+
+  const repoGit = simpleGit(repoDir);
+  try {
+    await repoGit.fetch(['--depth', '1', '--filter=blob:none']);
+  } catch {
+    // ignore fetch errors; pull may still work
+  }
+  // Best-effort: try to fast-forward current branch
+  try {
+    await repoGit.pull(['--ff-only']);
+  } catch {
+    // ignore ff-only failures (e.g. detached HEAD) — user can clean manually
+  }
+  return repoDir;
+}
+
+module.exports = { ensureRepo };
+

package/src/lib/http.js

@@ -0,0 +1,42 @@
+let proxyInitialized = false;
+
+function getProxyUrlFromEnv() {
+  return (
+    process.env.SKILLMANAGER_PROXY ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy ||
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    null
+  );
+}
+
+function ensureProxyInitialized() {
+  if (proxyInitialized) return;
+  proxyInitialized = true;
+
+  const proxyUrl = getProxyUrlFromEnv();
+  if (!proxyUrl) return;
+
+  try {
+    // Node 20+ ships undici. Use ProxyAgent so global fetch respects proxy.
+    // eslint-disable-next-line global-require
+    const { ProxyAgent, setGlobalDispatcher } = require('undici');
+    setGlobalDispatcher(new ProxyAgent(proxyUrl));
+    // eslint-disable-next-line no-console
+    console.log(`使用代理：${proxyUrl}`);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('警告：初始化代理失败，将不使用代理。');
+    // eslint-disable-next-line no-console
+    console.warn(e?.message || String(e));
+  }
+}
+
+async function httpFetch(url, options) {
+  ensureProxyInitialized();
+  return await fetch(url, options);
+}
+
+module.exports = { httpFetch };
+

package/src/lib/installed.js

@@ -0,0 +1,35 @@
+const path = require('path');
+const fsp = require('fs/promises');
+const fs = require('fs');
+const matter = require('gray-matter');
+
+async function listInstalledSkills(targetDir) {
+  try {
+    const entries = await fsp.readdir(targetDir, { withFileTypes: true });
+    const skills = [];
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const skillDir = path.join(targetDir, e.name);
+      const skillMd = path.join(skillDir, 'SKILL.md');
+      if (!fs.existsSync(skillMd)) continue;
+      let description = '';
+      try {
+        const raw = await fsp.readFile(skillMd, 'utf8');
+        const parsed = matter(raw);
+        if (parsed?.data?.description) description = String(parsed.data.description).trim();
+      } catch {}
+      skills.push({
+        name: e.name,
+        description,
+        skillDir
+      });
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return skills;
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { listInstalledSkills };
+

package/src/lib/local-install.js

@@ -0,0 +1,35 @@
+const path = require('path');
+const fs = require('fs');
+const fsp = require('fs/promises');
+
+function isPathInside(targetPath, targetDir) {
+  const resolvedTargetPath = path.resolve(targetPath);
+  const resolvedTargetDir = path.resolve(targetDir);
+  const resolvedTargetDirWithSep = resolvedTargetDir.endsWith(path.sep) ? resolvedTargetDir : resolvedTargetDir + path.sep;
+  return resolvedTargetPath.startsWith(resolvedTargetDirWithSep);
+}
+
+async function installFromLocalSkillDir({ skillDir, targetDir }) {
+  const skillMd = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillMd)) {
+    throw new Error(`SKILL.md not found: ${skillMd}`);
+  }
+
+  const skillName = path.basename(skillDir);
+  const targetPath = path.join(targetDir, skillName);
+
+  await fsp.mkdir(targetDir, { recursive: true });
+  if (!isPathInside(targetPath, targetDir)) {
+    throw new Error(`Security error: target path outside targetDir: ${targetPath}`);
+  }
+
+  // overwrite for deterministic bootstrap/update
+  await fsp.rm(targetPath, { recursive: true, force: true });
+  // Node 20: fs.promises.cp exists
+  await fsp.cp(skillDir, targetPath, { recursive: true, dereference: true });
+
+  return { skillName, targetPath };
+}
+
+module.exports = { installFromLocalSkillDir };
+

package/src/lib/manifest.js

@@ -0,0 +1,84 @@
+const path = require('path');
+const { readJson, fileExists, writeJson } = require('./fs');
+const { getAppPaths } = require('./paths');
+
+function getBuiltinManifestPath() {
+  // src/lib -> src -> project root
+  return path.resolve(__dirname, '../../manifests/sources.json');
+}
+
+function getUserManifestPath() {
+  const appPaths = getAppPaths();
+  return path.join(appPaths.configDir, 'sources.json');
+}
+
+async function loadSourcesManifest() {
+  const builtinPath = getBuiltinManifestPath();
+  const userPath = getUserManifestPath();
+
+  const builtin = await readJson(builtinPath);
+
+  // Ensure user manifest exists (copy builtin on first run)
+  if (!(await fileExists(userPath))) {
+    await writeJson(userPath, builtin);
+  }
+
+  let manifestPath = userPath;
+  let manifest;
+  try {
+    manifest = await readJson(manifestPath);
+  } catch {
+    // fallback to builtin if user file is corrupted
+    manifestPath = builtinPath;
+    manifest = await readJson(manifestPath);
+  }
+
+  // Merge-in new builtin sources by id (non-destructive):
+  // - keep user's existing entries as-is (including enabled flags)
+  // - add any builtin sources missing from user
+  // - bump version to max(builtin, user)
+  if (manifestPath === userPath) {
+    const userSources = Array.isArray(manifest?.sources) ? manifest.sources : [];
+    const userIds = new Set(userSources.map((s) => s && s.id).filter(Boolean));
+    const builtinSources = Array.isArray(builtin?.sources) ? builtin.sources : [];
+
+    const mergedSources = [...userSources];
+    for (const s of builtinSources) {
+      if (!s?.id) continue;
+      if (!userIds.has(s.id)) mergedSources.push(s);
+    }
+
+    const mergedVersion = Math.max(Number(manifest?.version || 1), Number(builtin?.version || 1));
+    const changed = mergedVersion !== Number(manifest?.version || 1) || mergedSources.length !== userSources.length;
+
+    if (changed) {
+      manifest = { ...(manifest || {}), version: mergedVersion, sources: mergedSources };
+      await writeJson(userPath, manifest);
+    }
+  }
+
+  const sources = Array.isArray(manifest?.sources) ? manifest.sources : [];
+  return { version: manifest?.version ?? 1, sources, manifestPath };
+}
+
+async function readUserSourcesManifest() {
+  const builtinPath = getBuiltinManifestPath();
+  const userPath = getUserManifestPath();
+
+  if (!(await fileExists(userPath))) {
+    const builtin = await readJson(builtinPath);
+    await writeJson(userPath, builtin);
+  }
+  const manifest = await readJson(userPath);
+  const sources = Array.isArray(manifest?.sources) ? manifest.sources : [];
+  return { manifest, sources, userPath };
+}
+
+async function writeUserSourcesManifest(manifest) {
+  const userPath = getUserManifestPath();
+  await writeJson(userPath, manifest);
+  return userPath;
+}
+
+module.exports = { loadSourcesManifest, getUserManifestPath, readUserSourcesManifest, writeUserSourcesManifest };
+

package/src/lib/openskills.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const { spawn } = require('child_process');
+
+function getOpenSkillsCliPath() {
+  // openskills bin points to dist/cli.js
+  return require.resolve('openskills/dist/cli.js');
+}
+
+async function runOpenSkills(args, opts = {}) {
+  const cliPath = getOpenSkillsCliPath();
+  const node = process.execPath;
+  return await new Promise((resolve, reject) => {
+    const child = spawn(node, [cliPath, ...args], {
+      cwd: opts.cwd || process.cwd(),
+      stdio: 'inherit',
+      windowsHide: true
+    });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) return resolve();
+      reject(new Error(`openskills exited with code ${code}`));
+    });
+  });
+}
+
+function buildOpenSkillsFlags({ globalInstall, universal }) {
+  const flags = [];
+  if (globalInstall) flags.push('--global');
+  if (universal) flags.push('--universal');
+  return flags;
+}
+
+async function installSkillDir({ skillDir, globalInstall, universal }) {
+  const flags = buildOpenSkillsFlags({ globalInstall, universal });
+  await runOpenSkills(['install', skillDir, ...flags, '--yes']);
+}
+
+async function installSourceRef({ ref, globalInstall, universal }) {
+  const flags = buildOpenSkillsFlags({ globalInstall, universal });
+  await runOpenSkills(['install', ref, ...flags, '--yes']);
+}
+
+async function syncAgents({ output, cwd }) {
+  const args = ['sync', '--yes'];
+  if (output) args.push('--output', path.resolve(cwd || process.cwd(), output));
+  await runOpenSkills(args, { cwd });
+}
+
+module.exports = { installSkillDir, installSourceRef, syncAgents, runOpenSkills };
+

package/src/lib/paths.js

@@ -0,0 +1,44 @@
+const path = require('path');
+const os = require('os');
+
+function getAppPaths() {
+  const home = os.homedir();
+  const platform = process.platform;
+
+  let configDir;
+  let cacheDir;
+  let dataDir;
+  let logDir;
+  let tempDir;
+
+  if (platform === 'win32') {
+    const roaming = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    const local = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    const tmp = process.env.TEMP || process.env.TMP || path.join(local, 'Temp');
+
+    configDir = path.join(roaming, 'skillmanager');
+    cacheDir = path.join(local, 'skillmanager', 'Cache');
+    dataDir = path.join(local, 'skillmanager', 'Data');
+    logDir = path.join(local, 'skillmanager', 'Logs');
+    tempDir = path.join(tmp, 'skillmanager');
+  } else {
+    configDir = process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, 'skillmanager') : path.join(home, '.config', 'skillmanager');
+    cacheDir = process.env.XDG_CACHE_HOME ? path.join(process.env.XDG_CACHE_HOME, 'skillmanager') : path.join(home, '.cache', 'skillmanager');
+    dataDir = process.env.XDG_DATA_HOME ? path.join(process.env.XDG_DATA_HOME, 'skillmanager') : path.join(home, '.local', 'share', 'skillmanager');
+    logDir = path.join(cacheDir, 'logs');
+    tempDir = path.join(os.tmpdir(), 'skillmanager');
+  }
+
+  return {
+    cacheDir,
+    configDir,
+    dataDir,
+    logDir,
+    tempDir,
+    reposDir: path.join(cacheDir, 'repos'),
+    profilesDir: path.join(configDir, 'profiles')
+  };
+}
+
+module.exports = { getAppPaths };
+

package/src/lib/profiles.js

@@ -0,0 +1,31 @@
+const path = require('path');
+const { fileExists, readJson, writeJson, ensureDir } = require('./fs');
+
+function profilePath({ profilesDir, profileName }) {
+  const safe = String(profileName || 'default').replace(/[^a-zA-Z0-9._-]+/g, '_');
+  return path.join(profilesDir, `${safe}.json`);
+}
+
+async function loadProfile({ profilesDir, profileName }) {
+  const p = profilePath({ profilesDir, profileName });
+  if (!(await fileExists(p))) return null;
+  try {
+    return await readJson(p);
+  } catch {
+    return null;
+  }
+}
+
+async function saveProfile({ profilesDir, profileName, selectedSkillIds }) {
+  await ensureDir(profilesDir);
+  const p = profilePath({ profilesDir, profileName });
+  await writeJson(p, {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    selectedSkillIds: Array.isArray(selectedSkillIds) ? selectedSkillIds : []
+  });
+  return p;
+}
+
+module.exports = { loadProfile, saveProfile, profilePath };
+

package/src/lib/scan.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const fsp = require('fs/promises');
+const fg = require('fast-glob');
+const matter = require('gray-matter');
+
+async function scanSkillsInRepo({ sourceId, sourceName, repoDir }) {
+  const entries = await fg(['**/SKILL.md'], {
+    cwd: repoDir,
+    dot: false,
+    onlyFiles: true,
+    ignore: ['**/node_modules/**', '**/.git/**']
+  });
+
+  const skills = [];
+  for (const relSkillMd of entries) {
+    const absSkillMd = path.join(repoDir, relSkillMd);
+    const skillDir = path.dirname(absSkillMd);
+    let name = path.basename(skillDir);
+    let description = '';
+    try {
+      const raw = await fsp.readFile(absSkillMd, 'utf8');
+      const parsed = matter(raw);
+      if (parsed?.data?.name) name = String(parsed.data.name).trim();
+      if (parsed?.data?.description) description = String(parsed.data.description).trim();
+    } catch {
+      // ignore parse errors
+    }
+
+    const relSkillDir = path.relative(repoDir, skillDir).replace(/\\/g, '/');
+    skills.push({
+      id: `${sourceId}:${relSkillDir}`,
+      sourceId,
+      sourceName,
+      name,
+      description,
+      skillDir,
+      skillMd: absSkillMd
+    });
+  }
+
+  // stable sort: by source then name
+  skills.sort((a, b) => {
+    if (a.sourceId !== b.sourceId) return a.sourceId.localeCompare(b.sourceId);
+    return a.name.localeCompare(b.name);
+  });
+  return skills;
+}
+
+module.exports = { scanSkillsInRepo };
+

package/src/lib/source-utils.js

@@ -0,0 +1,62 @@
+function sanitizeId(id) {
+  return String(id).replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+function parseGitHubRef(input) {
+  const raw = String(input || '').trim();
+  if (!raw) return null;
+
+  // owner/repo
+  const mRef = raw.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/);
+  if (mRef) {
+    const owner = mRef[1];
+    const repo = mRef[2];
+    return {
+      kind: 'github',
+      owner,
+      repo,
+      openskillsRef: `${owner}/${repo}`,
+      httpsRepo: `https://github.com/${owner}/${repo}.git`
+    };
+  }
+
+  // https://github.com/owner/repo(.git)?
+  const mHttps = raw.match(/^https?:\/\/github\.com\/([^/]+)\/([^/#?]+?)(?:\.git)?\/?$/i);
+  if (mHttps) {
+    const owner = mHttps[1];
+    const repo = mHttps[2];
+    return {
+      kind: 'github',
+      owner,
+      repo,
+      openskillsRef: `${owner}/${repo}`,
+      httpsRepo: `https://github.com/${owner}/${repo}.git`
+    };
+  }
+
+  // git@github.com:owner/repo(.git)
+  const mSsh = raw.match(/^git@github\.com:([^/]+)\/([^/#?]+?)(?:\.git)?$/i);
+  if (mSsh) {
+    const owner = mSsh[1];
+    const repo = mSsh[2];
+    return {
+      kind: 'github',
+      owner,
+      repo,
+      openskillsRef: `${owner}/${repo}`,
+      httpsRepo: `https://github.com/${owner}/${repo}.git`,
+      sshRepo: `git@github.com:${owner}/${repo}.git`
+    };
+  }
+
+  return null;
+}
+
+function defaultSourceIdFromInput(input) {
+  const gh = parseGitHubRef(input);
+  if (gh) return sanitizeId(`${gh.owner}-${gh.repo}`);
+  return sanitizeId(input);
+}
+
+module.exports = { sanitizeId, parseGitHubRef, defaultSourceIdFromInput };
+