sophhub 0.1.0

package/src/commands/download.js

@@ -0,0 +1,103 @@
+import chalk from 'chalk';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { findSkill } from '../utils/versions.js';
+import { getSkillDir } from '../utils/paths.js';
+import { loadConfig } from '../utils/config.js';
+import { downloadFromGitlab } from '../utils/gitlab.js';
+
+async function confirmOverwrite(destDir) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(
+      chalk.yellow(`  "${destDir}" already exists. Overwrite? [y/N] `),
+    );
+    return answer.trim().toLowerCase() === 'y';
+  } finally {
+    rl.close();
+  }
+}
+
+async function downloadFromBuiltin(type, skillName, outputDir) {
+  const srcDir = getSkillDir(type, skillName);
+
+  try {
+    await fs.access(srcDir);
+  } catch {
+    throw new Error(
+      `Skill directory not found in package: ${srcDir}\n` +
+        'The bundled skills may be outdated. Try --source gitlab for the latest version.',
+    );
+  }
+
+  const destDir = path.join(outputDir, skillName);
+  await fs.cp(srcDir, destDir, { recursive: true });
+  return destDir;
+}
+
+export function registerDownloadCommand(program) {
+  program
+    .command('download')
+    .description('Download a skill to local directory')
+    .argument('<skill-name>', 'Name of the skill to download')
+    .option('-o, --output <dir>', 'Target directory (default: current directory)')
+    .option('-s, --source <source>', 'Data source: builtin (default) or gitlab')
+    .action(async (skillName, opts) => {
+      try {
+        const config = await loadConfig();
+        const source = opts.source || config.defaultSource || 'builtin';
+        const outputDir = path.resolve(opts.output || config.defaultOutput || '.');
+
+        if (source !== 'builtin' && source !== 'gitlab') {
+          console.error(chalk.red(`Invalid source "${source}". Use "builtin" or "gitlab".`));
+          process.exit(1);
+        }
+
+        const skill = await findSkill(skillName);
+        if (!skill) {
+          console.error(chalk.red(`Skill "${skillName}" not found.`));
+          console.error(chalk.gray('Run "sophhub list" to see all available skills.'));
+          process.exit(1);
+        }
+
+        const destDir = path.join(outputDir, skillName);
+
+        try {
+          await fs.access(destDir);
+          const ok = await confirmOverwrite(destDir);
+          if (!ok) {
+            console.log(chalk.gray('Cancelled.'));
+            return;
+          }
+          await fs.rm(destDir, { recursive: true, force: true });
+        } catch {
+          // dest does not exist, proceed
+        }
+
+        await fs.mkdir(outputDir, { recursive: true });
+
+        console.log();
+        console.log(chalk.gray(`  Downloading ${skillName} from ${source}...`));
+
+        let result;
+        if (source === 'gitlab') {
+          const repoUrl = config.gitlabRepo;
+          result = await downloadFromGitlab(repoUrl, skill.type, skillName, outputDir);
+        } else {
+          result = await downloadFromBuiltin(skill.type, skillName, outputDir);
+        }
+
+        console.log();
+        console.log(chalk.green('  ✓ Download complete'));
+        console.log(chalk.gray(`    Skill:   ${skill.name}`));
+        console.log(chalk.gray(`    Version: ${skill.version}`));
+        console.log(chalk.gray(`    Source:  ${source}`));
+        console.log(chalk.gray(`    Path:    ${result}`));
+        console.log();
+      } catch (err) {
+        console.error(chalk.red(`\n  Failed to download: ${err.message}\n`));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/list.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { parseVersions } from '../utils/versions.js';
+
+export function registerListCommand(program) {
+  program
+    .command('list')
+    .description('List all available skills')
+    .option('-t, --type <type>', 'Filter by type: builtin or store')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        let skills = await parseVersions();
+
+        if (opts.type) {
+          const t = opts.type.toLowerCase();
+          if (t !== 'builtin' && t !== 'store') {
+            console.error(chalk.red(`Invalid type "${opts.type}". Use "builtin" or "store".`));
+            process.exit(1);
+          }
+          skills = skills.filter((s) => s.type === t);
+        }
+
+        if (skills.length === 0) {
+          if (opts.json) {
+            console.log('[]');
+          } else {
+            console.log(chalk.yellow('No skills found.'));
+          }
+          return;
+        }
+
+        if (opts.json) {
+          console.log(JSON.stringify(skills, null, 2));
+          return;
+        }
+
+        const table = new Table({
+          head: [
+            chalk.cyan('Skill'),
+            chalk.cyan('Type'),
+            chalk.cyan('Version'),
+            chalk.cyan('Updated At'),
+          ],
+          style: { head: [], border: [] },
+        });
+
+        for (const s of skills) {
+          table.push([
+            s.name,
+            s.type === 'builtin' ? chalk.blue(s.type) : chalk.green(s.type),
+            s.version,
+            s.updatedAt,
+          ]);
+        }
+
+        console.log();
+        console.log(table.toString());
+        console.log();
+        console.log(chalk.gray(`  Total: ${skills.length} skills`));
+        console.log();
+      } catch (err) {
+        console.error(chalk.red(`Failed to list skills: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/src/utils/config.js

@@ -0,0 +1,24 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_PATH = path.join(os.homedir(), '.sophhubrc.json');
+
+const DEFAULTS = {
+  defaultOutput: '.',
+  defaultSource: 'builtin',
+  gitlabRepo: 'git@gitlab.sophgo.vip:llm-open-platform/sophclaw-skills.git',
+};
+
+export async function loadConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf-8');
+    return { ...DEFAULTS, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export async function saveConfig(config) {
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}

package/src/utils/gitlab.js

@@ -0,0 +1,67 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Download a skill directory from GitLab using `git archive --remote`.
+ * Falls back to sparse-checkout if archive is not supported by the server.
+ */
+export async function downloadFromGitlab(repoUrl, type, skillName, outputDir) {
+  const destDir = path.join(outputDir, skillName);
+  const subPath = `${type}/${skillName}`;
+
+  // Try git archive first (most efficient, single-command)
+  try {
+    await fs.mkdir(destDir, { recursive: true });
+    const { stdout } = await execFileAsync(
+      'git',
+      ['archive', '--remote', repoUrl, 'HEAD', subPath],
+      { maxBuffer: 50 * 1024 * 1024 },
+    );
+
+    // pipe tar output through extraction
+    const tar = execFileAsync('tar', ['-x', '-C', outputDir], {
+      maxBuffer: 50 * 1024 * 1024,
+    });
+    tar.child.stdin.write(stdout);
+    tar.child.stdin.end();
+    await tar;
+
+    // git archive extracts to {type}/{skillName}/, move to {outputDir}/{skillName}/
+    const extracted = path.join(outputDir, type, skillName);
+    if (extracted !== destDir) {
+      await fs.cp(extracted, destDir, { recursive: true });
+      await fs.rm(path.join(outputDir, type), { recursive: true, force: true });
+    }
+    return destDir;
+  } catch {
+    // archive --remote not supported, fall back to sparse checkout
+  }
+
+  return downloadViaSparseCheckout(repoUrl, subPath, destDir);
+}
+
+async function downloadViaSparseCheckout(repoUrl, subPath, destDir) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sophhub-'));
+
+  try {
+    await execFileAsync(
+      'git',
+      ['clone', '--filter=blob:none', '--sparse', '--depth=1', repoUrl, tmpDir],
+      { timeout: 120_000 },
+    );
+
+    await execFileAsync('git', ['sparse-checkout', 'set', subPath], { cwd: tmpDir });
+
+    const src = path.join(tmpDir, subPath);
+    await fs.cp(src, destDir, { recursive: true });
+
+    return destDir;
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}

package/src/utils/paths.js

@@ -0,0 +1,19 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const PACKAGE_ROOT = path.resolve(__dirname, '../..');
+
+export function getSkillsDir() {
+  return path.join(PACKAGE_ROOT, 'skills');
+}
+
+export function getVersionsPath() {
+  return path.join(getSkillsDir(), 'VERSIONS.md');
+}
+
+export function getSkillDir(type, skillName) {
+  return path.join(getSkillsDir(), type, skillName);
+}

package/src/utils/versions.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs/promises';
+import { getVersionsPath } from './paths.js';
+
+/**
+ * Parse VERSIONS.md markdown table into an array of skill objects.
+ * Expected format:
+ *   | Skill | Type | Version | Updated At |
+ *   | --- | --- | --- | --- |
+ *   | weather | builtin | 1.0.0 | 2026-04-08 |
+ */
+export async function parseVersions() {
+  const content = await fs.readFile(getVersionsPath(), 'utf-8');
+  const lines = content.split('\n').filter((l) => l.trim().startsWith('|'));
+
+  // skip header row and separator row (first two | lines)
+  const dataLines = lines.slice(2);
+
+  return dataLines
+    .map((line) => {
+      const cells = line
+        .split('|')
+        .map((c) => c.trim())
+        .filter(Boolean);
+      if (cells.length < 4) return null;
+      return {
+        name: cells[0],
+        type: cells[1],
+        version: cells[2],
+        updatedAt: cells[3],
+      };
+    })
+    .filter(Boolean);
+}
+
+export async function findSkill(skillName) {
+  const skills = await parseVersions();
+  return skills.find((s) => s.name === skillName) || null;
+}