nova-terminal-assistant 0.1.0

package/src/core/extensions/SkillInstaller.ts

@@ -0,0 +1,257 @@
+// ============================================================================
+// SkillInstaller - Install skills from GitHub repositories
+// ============================================================================
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+
+export interface SkillInstallOptions {
+  /** GitHub repository URL or shorthand (e.g., "obra/superpowers") */
+  source: string;
+  /** Target directory for installation (default: ~/.nova/skills/) */
+  targetDir?: string;
+  /** Specific skill names to install (default: all) */
+  skills?: string[];
+  /** Force overwrite existing skills */
+  force?: boolean;
+}
+
+export interface InstalledSkill {
+  name: string;
+  path: string;
+  source: string;
+}
+
+/**
+ * Install skills from GitHub repositories
+ * 
+ * Supports formats:
+ * - "obra/superpowers" -> https://github.com/obra/superpowers
+ * - "https://github.com/obra/superpowers"
+ * - Full GitHub URL
+ */
+export class SkillInstaller {
+  private baseDir: string;
+
+  constructor(baseDir?: string) {
+    this.baseDir = baseDir || path.join(os.homedir(), '.nova', 'skills');
+  }
+
+  /**
+   * Install skills from a GitHub repository
+   */
+  async install(options: SkillInstallOptions): Promise<InstalledSkill[]> {
+    const { source, targetDir, skills: specificSkills, force } = options;
+    const target = targetDir || this.baseDir;
+
+    // Parse GitHub URL
+    const repoUrl = this.parseGitHubUrl(source);
+    const repoName = repoUrl.split('/').pop() || 'unknown';
+
+    console.log(`Installing skills from ${repoUrl}...`);
+
+    // Create temp directory for cloning
+    const tempDir = path.join(os.tmpdir(), `nova-skills-${Date.now()}`);
+
+    try {
+      // Clone repository
+      console.log(`  Cloning repository...`);
+      execSync(`git clone --depth 1 ${repoUrl} "${tempDir}"`, { stdio: 'pipe' });
+
+      // Find skills directory
+      const skillsDir = this.findSkillsDirectory(tempDir);
+      if (!skillsDir) {
+        throw new Error(`No skills directory found in ${repoName}`);
+      }
+
+      // Get all skills
+      const availableSkills = this.listSkills(skillsDir);
+      const toInstall = specificSkills 
+        ? availableSkills.filter(s => specificSkills.includes(s))
+        : availableSkills;
+
+      if (toInstall.length === 0) {
+        throw new Error(`No matching skills found`);
+      }
+
+      // Install each skill
+      const installed: InstalledSkill[] = [];
+      for (const skillName of toInstall) {
+        const srcPath = path.join(skillsDir, skillName);
+        const destPath = path.join(target, skillName);
+
+        // Check if exists
+        if (fs.existsSync(destPath) && !force) {
+          console.log(`  ⚠ ${skillName} already exists, use --force to overwrite`);
+          continue;
+        }
+
+        // Copy skill
+        this.copySkill(srcPath, destPath);
+        installed.push({ name: skillName, path: destPath, source: repoUrl });
+        console.log(`  ✓ Installed: ${skillName}`);
+      }
+
+      return installed;
+    } finally {
+      // Cleanup temp directory
+      this.rmrf(tempDir);
+    }
+  }
+
+  /**
+   * Parse various Git repository URL formats (GitHub, Gitee, etc.)
+   */
+  private parseGitHubUrl(source: string): string {
+    // Already a full URL (GitHub, Gitee, GitLab, etc.)
+    if (source.startsWith('https://') || source.startsWith('git@')) {
+      return source;
+    }
+
+    // Gitee shorthand: "gitee:owner/repo"
+    if (source.startsWith('gitee:')) {
+      const repoPath = source.substring(6); // Remove 'gitee:'
+      return `https://gitee.com/${repoPath}.git`;
+    }
+
+    // GitHub shorthand: "owner/repo"
+    if (source.match(/^[\w-]+\/[\w-]+$/)) {
+      return `https://github.com/${source}.git`;
+    }
+
+    // Assume it's a GitHub shorthand
+    return `https://github.com/${source}.git`;
+  }
+
+  /**
+   * Find the skills directory in a repository
+   */
+  private findSkillsDirectory(repoDir: string): string | null {
+    // Common skill directory names
+    const candidates = ['skills', '.claude/skills', 'plugins', '.skills'];
+
+    for (const name of candidates) {
+      const fullPath = path.join(repoDir, name);
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+        // Verify it contains SKILL.md files
+        const entries = fs.readdirSync(fullPath);
+        const hasSkills = entries.some(entry => {
+          const skillPath = path.join(fullPath, entry);
+          return fs.statSync(skillPath).isDirectory() && 
+                 fs.existsSync(path.join(skillPath, 'SKILL.md'));
+        });
+        if (hasSkills) return fullPath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * List all skill directories
+   */
+  private listSkills(skillsDir: string): string[] {
+    return fs.readdirSync(skillsDir).filter(entry => {
+      const skillPath = path.join(skillsDir, entry);
+      return fs.statSync(skillPath).isDirectory() &&
+             fs.existsSync(path.join(skillPath, 'SKILL.md'));
+    });
+  }
+
+  /**
+   * Copy a skill directory
+   */
+  private copySkill(src: string, dest: string): void {
+    // Create destination
+    fs.mkdirSync(dest, { recursive: true });
+
+    // Copy all files
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copySkill(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Recursive delete
+   */
+  private rmrf(dir: string): void {
+    if (!fs.existsSync(dir)) return;
+    
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        this.rmrf(fullPath);
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+    fs.rmdirSync(dir);
+  }
+
+  /**
+   * List installed skills
+   */
+  listInstalled(): string[] {
+    if (!fs.existsSync(this.baseDir)) return [];
+    return fs.readdirSync(this.baseDir).filter(name => {
+      return fs.existsSync(path.join(this.baseDir, name, 'SKILL.md'));
+    });
+  }
+
+  /**
+   * Uninstall a skill
+   */
+  uninstall(skillName: string): boolean {
+    const skillPath = path.join(this.baseDir, skillName);
+    if (!fs.existsSync(skillPath)) return false;
+    this.rmrf(skillPath);
+    return true;
+  }
+}
+
+/**
+ * Popular skill repositories
+ */
+export const POPULAR_SKILL_REPOS = {
+  superpowers: {
+    // Default to Gitee mirror for better accessibility in China
+    url: 'gitee:anderson2/superpowers',
+    description: 'Agentic skills framework - TDD, debugging, code review, planning',
+    skills: [
+      'brainstorming',
+      'writing-plans',
+      'executing-plans',
+      'test-driven-development',
+      'systematic-debugging',
+      'requesting-code-review',
+      'receiving-code-review',
+      'using-git-worktrees',
+      'finishing-a-development-branch',
+      'subagent-driven-development',
+      'verification-before-completion',
+      'writing-skills',
+    ],
+  },
+};
+
+/**
+ * Quick install function
+ */
+export async function installSuperpowers(baseDir?: string): Promise<InstalledSkill[]> {
+  const installer = new SkillInstaller(baseDir);
+  return installer.install({
+    source: 'gitee:anderson2/superpowers',
+    force: false,
+  });
+}

package/src/core/extensions/SkillRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillRegistry.d.ts","sourceRoot":"","sources":["SkillRegistry.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,QAAQ,EAAE,aAAa,CAAC;IACxB,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,sBAAsB;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,WAAW,CAAS;gBAEhB,SAAS,CAAC,EAAE,MAAM;IAI9B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBjC;;OAEG;IACG,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBrD;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAYxD;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA4DnE;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAOxC;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAa5C;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,OAAO,CAAC,YAAY;IAkBpB;;OAEG;YACW,SAAS;IAkCvB;;OAEG;IACH,OAAO,CAAC,YAAY;IAwDpB;;OAEG;YACW,eAAe;CAG9B"}

package/src/core/extensions/SkillRegistry.ts

@@ -0,0 +1,361 @@
+// ============================================================================
+// SkillRegistry - Register, discover, and manage agent skills
+// Reference: WorkBuddy skill system with metadata tracking
+// ============================================================================
+
+import { readFile, writeFile, mkdir, readdir, stat, rm } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+
+// --- Types ---
+
+export interface SkillMetadata {
+  /** Unique skill identifier */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Author */
+  author?: string;
+  /** Version (semver) */
+  version: string;
+  /** Tags for categorization and search */
+  tags: string[];
+  /** Supported model providers (empty = all) */
+  providers?: string[];
+  /** Required tools for this skill */
+  requiredTools?: string[];
+  /** Whether this skill was auto-generated */
+  autoGenerated?: boolean;
+  /** Creation date */
+  createdAt: string;
+  /** Last update date */
+  updatedAt: string;
+  /** File size in bytes */
+  sizeBytes?: number;
+  /** Reviewed at date */
+  reviewedAt?: string;
+}
+
+export interface SkillDefinition {
+  /** Skill metadata */
+  metadata: SkillMetadata;
+  /** SKILL.md content (the skill prompt/instructions) */
+  content: string;
+  /** Associated script files */
+  scripts?: Record<string, string>;
+  /** Associated reference files */
+  references?: string[];
+}
+
+export interface SkillSearchParams {
+  /** Search query string */
+  query?: string;
+  /** Filter by tags */
+  tags?: string[];
+  /** Filter by provider compatibility */
+  provider?: string;
+  /** Include auto-generated skills */
+  includeAutoGenerated?: boolean;
+  /** Maximum results */
+  limit?: number;
+}
+
+// --- SkillRegistry ---
+
+export class SkillRegistry {
+  private skillsDir: string;
+  private cache = new Map<string, SkillDefinition>();
+  private initialized = false;
+
+  constructor(skillsDir?: string) {
+    this.skillsDir = skillsDir || join(process.env.HOME || process.env.USERPROFILE || '~', '.nova-cli', 'skills');
+  }
+
+  /**
+   * Initialize the registry by loading all skills from disk.
+   */
+  async initialize(): Promise<void> {
+    try {
+      await mkdir(this.skillsDir, { recursive: true });
+    } catch {
+      // Directory may already exist
+    }
+
+    const entries = await readdir(this.skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = join(this.skillsDir, entry.name);
+        try {
+          const skill = await this.loadSkill(entry.name);
+          if (skill) {
+            this.cache.set(entry.name, skill);
+          }
+        } catch {
+          // Skip invalid skills
+        }
+      }
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Register a new skill.
+   */
+  async register(skill: SkillDefinition): Promise<void> {
+    const skillDir = join(this.skillsDir, skill.metadata.name);
+    await mkdir(skillDir, { recursive: true });
+
+    // Write SKILL.md
+    const skillMdPath = join(skillDir, 'SKILL.md');
+    const fullContent = this.buildSkillMd(skill.metadata, skill.content);
+    await writeFile(skillMdPath, fullContent, 'utf-8');
+
+    // Write script files
+    if (skill.scripts) {
+      const scriptsDir = join(skillDir, 'scripts');
+      await mkdir(scriptsDir, { recursive: true });
+      for (const [filename, content] of Object.entries(skill.scripts)) {
+        await writeFile(join(scriptsDir, filename), content, 'utf-8');
+      }
+    }
+
+    // Update cache
+    skill.metadata.updatedAt = new Date().toISOString();
+    this.cache.set(skill.metadata.name, skill);
+  }
+
+  /**
+   * Get a skill by name.
+   */
+  async get(name: string): Promise<SkillDefinition | null> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    if (this.cache.has(name)) {
+      return this.cache.get(name)!;
+    }
+
+    return this.loadSkill(name);
+  }
+
+  /**
+   * Search for skills matching the given criteria.
+   */
+  async search(params: SkillSearchParams): Promise<SkillDefinition[]> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    let results = Array.from(this.cache.values());
+
+    // Filter by auto-generated
+    if (!params.includeAutoGenerated) {
+      results = results.filter((s) => !s.metadata.autoGenerated);
+    }
+
+    // Filter by provider
+    if (params.provider) {
+      results = results.filter(
+        (s) =>
+          !s.metadata.providers ||
+          s.metadata.providers.length === 0 ||
+          s.metadata.providers.includes(params.provider!)
+      );
+    }
+
+    // Filter by tags
+    if (params.tags && params.tags.length > 0) {
+      results = results.filter((s) =>
+        params.tags!.some((tag) => s.metadata.tags.includes(tag))
+      );
+    }
+
+    // Filter by query
+    if (params.query) {
+      const query = params.query.toLowerCase();
+      results = results.filter(
+        (s) =>
+          s.metadata.name.toLowerCase().includes(query) ||
+          s.metadata.description.toLowerCase().includes(query) ||
+          s.metadata.tags.some((t) => t.toLowerCase().includes(query))
+      );
+    }
+
+    // Sort by relevance (name match first, then description match)
+    if (params.query) {
+      const query = params.query.toLowerCase();
+      results.sort((a, b) => {
+        const aNameMatch = a.metadata.name.toLowerCase().includes(query) ? 2 : 0;
+        const bNameMatch = b.metadata.name.toLowerCase().includes(query) ? 2 : 0;
+        const aDescMatch = a.metadata.description.toLowerCase().includes(query) ? 1 : 0;
+        const bDescMatch = b.metadata.description.toLowerCase().includes(query) ? 1 : 0;
+        return (bNameMatch + bDescMatch) - (aNameMatch + aDescMatch);
+      });
+    }
+
+    // Limit results
+    if (params.limit) {
+      results = results.slice(0, params.limit);
+    }
+
+    return results;
+  }
+
+  /**
+   * List all registered skills.
+   */
+  async list(): Promise<SkillDefinition[]> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return Array.from(this.cache.values());
+  }
+
+  /**
+   * Remove a skill.
+   */
+  async remove(name: string): Promise<boolean> {
+    const skillDir = join(this.skillsDir, name);
+
+    try {
+      await rm(skillDir, { recursive: true, force: true });
+    } catch {
+      return false;
+    }
+
+    this.cache.delete(name);
+    return true;
+  }
+
+  /**
+   * Get the skills directory path.
+   */
+  getSkillsDir(): string {
+    return this.skillsDir;
+  }
+
+  /**
+   * Build the full SKILL.md content with metadata header.
+   */
+  private buildSkillMd(metadata: SkillMetadata, content: string): string {
+    const header = `---
+name: ${metadata.name}
+description: ${metadata.description}
+version: ${metadata.version}
+author: ${metadata.author || 'unknown'}
+tags: ${metadata.tags.join(', ')}
+${metadata.providers ? `providers: ${metadata.providers.join(', ')}` : ''}
+${metadata.requiredTools ? `requiredTools: ${metadata.requiredTools.join(', ')}` : ''}
+${metadata.autoGenerated ? 'autoGenerated: true' : ''}
+createdAt: ${metadata.createdAt}
+updatedAt: ${metadata.updatedAt}
+---
+
+`;
+    return header + content;
+  }
+
+  /**
+   * Load a skill from disk.
+   */
+  private async loadSkill(name: string): Promise<SkillDefinition | null> {
+    const skillDir = join(this.skillsDir, name);
+    const skillMdPath = join(skillDir, 'SKILL.md');
+
+    try {
+      const rawContent = await readFile(skillMdPath, 'utf-8');
+      const { metadata, content } = this.parseSkillMd(rawContent);
+
+      // Load scripts
+      const scripts: Record<string, string> = {};
+      const scriptsDir = join(skillDir, 'scripts');
+      try {
+        const entries = await readdir(scriptsDir);
+        for (const entry of entries) {
+          if (entry.endsWith('.ts') || entry.endsWith('.js') || entry.endsWith('.sh') || entry.endsWith('.py')) {
+            scripts[entry] = await readFile(join(scriptsDir, entry), 'utf-8');
+          }
+        }
+      } catch {
+        // No scripts directory
+      }
+
+      const fileStat = await stat(skillMdPath);
+
+      return {
+        metadata: { ...metadata, sizeBytes: fileStat.size },
+        content,
+        scripts: Object.keys(scripts).length > 0 ? scripts : undefined,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Parse SKILL.md content into metadata and body.
+   */
+  private parseSkillMd(rawContent: string): {
+    metadata: SkillMetadata;
+    content: string;
+  } {
+    const frontmatterMatch = rawContent.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+      return {
+        metadata: {
+          name: 'unknown',
+          description: 'No description',
+          version: '0.0.0',
+          tags: [],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+        content: rawContent,
+      };
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const content = frontmatterMatch[2];
+
+    const parseField = (field: string): string => {
+      const match = frontmatter.match(new RegExp(`${field}:\\s*(.+)`));
+      return match ? match[1].trim() : '';
+    };
+
+    const parseArray = (field: string): string[] => {
+      const raw = parseField(field);
+      if (!raw) return [];
+      return raw.split(',').map((s) => s.trim()).filter(Boolean);
+    };
+
+    const parseBool = (field: string): boolean => {
+      const raw = parseField(field);
+      return raw.toLowerCase() === 'true';
+    };
+
+    const name = parseField('name') || 'unknown';
+    return {
+      metadata: {
+        name,
+        description: parseField('description'),
+        version: parseField('version') || '0.0.0',
+        author: parseField('author') || undefined,
+        tags: parseArray('tags'),
+        providers: parseArray('providers').length > 0 ? parseArray('providers') : undefined,
+        requiredTools: parseArray('requiredTools').length > 0 ? parseArray('requiredTools') : undefined,
+        autoGenerated: parseBool('autoGenerated'),
+        createdAt: parseField('createdAt') || new Date().toISOString(),
+        updatedAt: parseField('updatedAt') || new Date().toISOString(),
+      },
+      content,
+    };
+  }
+
+  /**
+   * Recursively remove a directory.
+   */
+  private async removeDirectory(dirPath: string): Promise<void> {
+    await rm(dirPath, { recursive: true, force: true });
+  }
+}