@looplia/looplia-cli 0.7.0 → 0.7.2

package/plugins/looplia-core/skills/plugin-registry-scanner/SKILL.md

@@ -1,108 +0,0 @@
----
-name: plugin-registry-scanner
-description: |
-  This skill should be used when the user wants to discover available looplia skills,
-  scan installed plugins, or list what capabilities are available. Use when someone says
-  "what looplia skills are installed", "list available skills", "scan plugins", "/build",
-  "what can looplia do", or "show me all looplia capabilities".
-
-  First step in looplia workflow building: scans plugins/*/skills/*/SKILL.md to build
-  a registry of available skills. Part of the skills-first architecture where one workflow
-  step invokes one skill-executor to orchestrate multiple skills.
-tools: Bash, Read, Glob
-model: claude-haiku-4-5-20251001
----
-
-# Plugin Registry Scanner
-
-Discover and catalog all skills from installed looplia plugins.
-
-## Purpose
-
-Scan the `plugins/*/skills/*/SKILL.md` directory structure to build a registry of available skills with their capabilities.
-
-## Process
-
-### 1. Scan Plugin Directories
-
-```bash
-bun plugins/looplia-core/skills/plugin-registry-scanner/scripts/scan-plugins.ts
-```
-
-This deterministic script returns a JSON registry of all discovered skills.
-
-### 2. Parse the Registry
-
-The script output contains:
-
-```json
-{
-  "plugins": [
-    {
-      "name": "looplia-writer",
-      "path": "plugins/looplia-writer",
-      "skills": [
-        {
-          "name": "media-reviewer",
-          "description": "Deep content analysis (structure, themes, narrative)",
-          "tools": ["Read", "Grep", "Glob"],
-          "model": "haiku",
-          "capabilities": ["content analysis", "theme extraction", "quote identification"]
-        }
-      ]
-    }
-  ],
-  "summary": {
-    "totalPlugins": 2,
-    "totalSkills": 7
-  }
-}
-```
-
-### 3. Infer Capabilities (Optional LLM Step)
-
-If capability inference is needed beyond what the script provides, analyze skill descriptions to extract:
-- Input types handled (video, audio, text, etc.)
-- Processing capabilities (analyze, transform, generate, etc.)
-- Output formats (JSON, markdown, structured data)
-
-## Output Schema
-
-```json
-{
-  "plugins": [
-    {
-      "name": "string",
-      "path": "string",
-      "skills": [
-        {
-          "name": "string",
-          "description": "string",
-          "tools": ["string"],
-          "model": "string",
-          "capabilities": ["string"]
-        }
-      ]
-    }
-  ],
-  "summary": {
-    "totalPlugins": "number",
-    "totalSkills": "number"
-  }
-}
-```
-
-## Usage
-
-This skill is typically invoked as the first step in workflow building:
-
-1. Scan available plugins and skills
-2. Pass registry to skill-capability-matcher
-3. Use matched skills in workflow-schema-composer
-
-## Notes
-
-- The scan script is deterministic (no LLM tokens)
-- Capabilities can be inferred from descriptions if not explicitly declared
-- Skills without SKILL.md files are skipped
-- Invalid frontmatter generates warnings but doesn't halt scanning

package/plugins/looplia-core/skills/plugin-registry-scanner/scripts/scan-plugins.ts

@@ -1,221 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Plugin Registry Scanner
- *
- * Deterministic script to scan installed plugins and catalog available skills.
- * Outputs a JSON registry to stdout.
- *
- * Usage: bun plugins/looplia-core/skills/plugin-registry-scanner/scripts/scan-plugins.ts [plugins-dir]
- */
-
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, join } from "node:path";
-import { parse as parseYaml } from "yaml";
-
-// Top-level regex for frontmatter extraction
-export const FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
-
-// Capability inference lookup table
-export const CAPABILITY_PATTERNS: [string, string][] = [
-  ["analy", "content analysis"],
-  ["review", "content review"],
-  ["theme", "theme extraction"],
-  ["extract", "theme extraction"],
-  ["quote", "quote identification"],
-  ["generat", "content generation"],
-  ["idea", "idea generation"],
-  ["hook", "idea generation"],
-  ["outline", "outline creation"],
-  ["transform", "content transformation"],
-  ["document", "structured output"],
-  ["structur", "structured output"],
-  ["assembl", "content assembly"],
-  ["combin", "content assembly"],
-  ["profile", "personalization"],
-  ["user", "personalization"],
-  ["valid", "validation"],
-];
-
-export type SkillInfo = {
-  name: string;
-  description: string;
-  tools?: string[];
-  model?: string;
-  capabilities: string[];
-};
-
-export type PluginInfo = {
-  name: string;
-  path: string;
-  skills: SkillInfo[];
-};
-
-export type Registry = {
-  plugins: PluginInfo[];
-  summary: {
-    totalPlugins: number;
-    totalSkills: number;
-  };
-};
-
-/**
- * Extract YAML frontmatter from markdown content
- */
-export function extractFrontmatter(
-  content: string
-): Record<string, unknown> | null {
-  const match = content.match(FRONTMATTER_REGEX);
-  if (!match) {
-    return null;
-  }
-
-  try {
-    return parseYaml(match[1]) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Infer capabilities from skill description using pattern matching
- */
-export function inferCapabilities(description: string): string[] {
-  const descLower = description.toLowerCase();
-  const capabilities = new Set<string>();
-
-  for (const [pattern, capability] of CAPABILITY_PATTERNS) {
-    if (descLower.includes(pattern)) {
-      capabilities.add(capability);
-    }
-  }
-
-  if (capabilities.size === 0) {
-    capabilities.add("general processing");
-  }
-
-  return [...capabilities];
-}
-
-/**
- * Scan a single skill directory
- */
-async function scanSkill(skillPath: string): Promise<SkillInfo | null> {
-  const skillMdPath = join(skillPath, "SKILL.md");
-
-  try {
-    const content = await readFile(skillMdPath, "utf-8");
-    const frontmatter = extractFrontmatter(content);
-
-    if (!(frontmatter?.name && frontmatter.description)) {
-      console.error(`Warning: Invalid frontmatter in ${skillMdPath}`);
-      return null;
-    }
-
-    const description =
-      typeof frontmatter.description === "string"
-        ? frontmatter.description.trim()
-        : String(frontmatter.description);
-
-    let tools: string[] | undefined;
-    if (Array.isArray(frontmatter.tools)) {
-      tools = frontmatter.tools.map(String);
-    } else if (typeof frontmatter.tools === "string") {
-      tools = frontmatter.tools.split(",").map((t: string) => t.trim());
-    }
-
-    return {
-      name: String(frontmatter.name),
-      description,
-      tools,
-      model: frontmatter.model ? String(frontmatter.model) : undefined,
-      capabilities: inferCapabilities(description),
-    };
-  } catch {
-    // SKILL.md doesn't exist or can't be read
-    return null;
-  }
-}
-
-/**
- * Scan a single plugin directory
- */
-async function scanPlugin(pluginPath: string): Promise<PluginInfo | null> {
-  const skillsDir = join(pluginPath, "skills");
-
-  try {
-    const skillsStat = await stat(skillsDir);
-    if (!skillsStat.isDirectory()) {
-      return null;
-    }
-  } catch {
-    // No skills directory
-    return null;
-  }
-
-  const skillDirs = await readdir(skillsDir);
-  const skills: SkillInfo[] = [];
-
-  for (const skillDir of skillDirs) {
-    const skillPath = join(skillsDir, skillDir);
-    const skillStat = await stat(skillPath);
-
-    if (skillStat.isDirectory()) {
-      const skill = await scanSkill(skillPath);
-      if (skill) {
-        skills.push(skill);
-      }
-    }
-  }
-
-  if (skills.length === 0) {
-    return null;
-  }
-
-  return {
-    name: basename(pluginPath),
-    path: pluginPath,
-    skills,
-  };
-}
-
-/**
- * Main scanner function
- */
-export async function scanPlugins(pluginsPath: string): Promise<Registry> {
-  const plugins: PluginInfo[] = [];
-
-  try {
-    const entries = await readdir(pluginsPath);
-
-    for (const entry of entries) {
-      const pluginPath = join(pluginsPath, entry);
-      const entryStat = await stat(pluginPath);
-
-      if (entryStat.isDirectory() && !entry.startsWith(".")) {
-        const plugin = await scanPlugin(pluginPath);
-        if (plugin) {
-          plugins.push(plugin);
-        }
-      }
-    }
-  } catch (error) {
-    console.error(`Error scanning plugins directory: ${error}`);
-  }
-
-  const totalSkills = plugins.reduce((sum, p) => sum + p.skills.length, 0);
-
-  return {
-    plugins,
-    summary: {
-      totalPlugins: plugins.length,
-      totalSkills,
-    },
-  };
-}
-
-// Main execution (only when run directly, not when imported)
-if (import.meta.main) {
-  const pluginsDir = process.argv[2] || "plugins";
-  const registry = await scanPlugins(pluginsDir);
-  console.log(JSON.stringify(registry, null, 2));
-}

package/plugins/looplia-core/skills/plugin-registry-scanner/test/scan-plugins.test.ts

@@ -1,260 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { join } from "node:path";
-import {
-  CAPABILITY_PATTERNS,
-  extractFrontmatter,
-  inferCapabilities,
-  scanPlugins,
-} from "../scripts/scan-plugins";
-
-// Use absolute path to ensure tests work from any directory
-const PLUGINS_DIR = join(import.meta.dir, "../../../..");
-
-describe("scan-plugins", () => {
-  describe("extractFrontmatter", () => {
-    it("should extract valid YAML frontmatter", () => {
-      const content = `---
-name: test-skill
-description: A test skill
-tools: Read, Write
----
-
-# Test Skill
-
-This is the body.`;
-
-      const result = extractFrontmatter(content);
-      expect(result).not.toBeNull();
-      expect(result?.name).toBe("test-skill");
-      expect(result?.description).toBe("A test skill");
-      expect(result?.tools).toBe("Read, Write");
-    });
-
-    it("should extract multiline description with pipe syntax", () => {
-      const content = `---
-name: multi-line
-description: |
-  This is a multiline
-  description with details.
-model: claude-haiku-4-5-20251001
----
-
-# Skill`;
-
-      const result = extractFrontmatter(content);
-      expect(result).not.toBeNull();
-      expect(result?.name).toBe("multi-line");
-      expect(result?.description).toContain("multiline");
-      expect(result?.model).toBe("claude-haiku-4-5-20251001");
-    });
-
-    it("should return null for content without frontmatter", () => {
-      const content = `# Just a heading
-
-No frontmatter here.`;
-
-      const result = extractFrontmatter(content);
-      expect(result).toBeNull();
-    });
-
-    it("should return null for invalid YAML", () => {
-      const content = `---
-name: test
-invalid: yaml: syntax: here
----
-
-# Test`;
-
-      const result = extractFrontmatter(content);
-      expect(result).toBeNull();
-    });
-
-    it("should return null for unclosed frontmatter", () => {
-      const content = `---
-name: unclosed
-description: Missing closing delimiter
-
-# Content`;
-
-      const result = extractFrontmatter(content);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("inferCapabilities", () => {
-    it("should infer content analysis capability", () => {
-      const result = inferCapabilities("Deep content analysis for videos");
-      expect(result).toContain("content analysis");
-    });
-
-    it("should infer theme extraction capability", () => {
-      const result = inferCapabilities("Extract key themes from documents");
-      expect(result).toContain("theme extraction");
-    });
-
-    it("should infer idea generation capability", () => {
-      const result = inferCapabilities("Generate creative ideas and hooks");
-      expect(result).toContain("idea generation");
-    });
-
-    it("should infer multiple capabilities from description", () => {
-      const result = inferCapabilities(
-        "Analyze content, generate ideas, and create outlines"
-      );
-      expect(result).toContain("content analysis");
-      expect(result).toContain("idea generation");
-      expect(result).toContain("outline creation");
-    });
-
-    it("should infer validation capability", () => {
-      const result = inferCapabilities("Validate workflow outputs");
-      expect(result).toContain("validation");
-    });
-
-    it("should infer personalization capability", () => {
-      const result = inferCapabilities("Read user profile for context");
-      expect(result).toContain("personalization");
-    });
-
-    it("should infer structured output capability", () => {
-      const result = inferCapabilities("Generate structured JSON documents");
-      expect(result).toContain("structured output");
-    });
-
-    it("should infer content assembly capability", () => {
-      const result = inferCapabilities("Assemble and combine content pieces");
-      expect(result).toContain("content assembly");
-    });
-
-    it("should return general processing for unknown descriptions", () => {
-      const result = inferCapabilities("Something completely different");
-      expect(result).toContain("general processing");
-      expect(result.length).toBe(1);
-    });
-
-    it("should be case-insensitive", () => {
-      const result = inferCapabilities("ANALYZE CONTENT");
-      expect(result).toContain("content analysis");
-    });
-
-    it("should not duplicate capabilities", () => {
-      // "analyze" and "analysis" should not create duplicate entries
-      const result = inferCapabilities("Analyze using analysis techniques");
-      const analysisCount = result.filter(
-        (c) => c === "content analysis"
-      ).length;
-      expect(analysisCount).toBe(1);
-    });
-  });
-
-  describe("CAPABILITY_PATTERNS", () => {
-    it("should have expected patterns defined", () => {
-      const patterns = CAPABILITY_PATTERNS.map(([p]) => p);
-      expect(patterns).toContain("analy");
-      expect(patterns).toContain("valid");
-      expect(patterns).toContain("generat");
-      expect(patterns).toContain("theme");
-    });
-
-    it("should map patterns to capabilities", () => {
-      const patternMap = Object.fromEntries(CAPABILITY_PATTERNS);
-      expect(patternMap.analy).toBe("content analysis");
-      expect(patternMap.valid).toBe("validation");
-      expect(patternMap.outline).toBe("outline creation");
-    });
-  });
-
-  describe("scanPlugins", () => {
-    it("should discover looplia-core skills", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-      const corePlugin = result.plugins.find((p) => p.name === "looplia-core");
-
-      expect(corePlugin).toBeDefined();
-      expect(corePlugin?.skills.length).toBeGreaterThan(0);
-
-      const skillNames = corePlugin?.skills.map((s) => s.name) ?? [];
-      expect(skillNames).toContain("plugin-registry-scanner");
-      expect(skillNames).toContain("workflow-executor");
-      expect(skillNames).toContain("skill-capability-matcher");
-    });
-
-    it("should discover looplia-writer skills", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-      const writerPlugin = result.plugins.find(
-        (p) => p.name === "looplia-writer"
-      );
-
-      expect(writerPlugin).toBeDefined();
-      expect(writerPlugin?.skills.length).toBeGreaterThan(0);
-
-      const skillNames = writerPlugin?.skills.map((s) => s.name) ?? [];
-      expect(skillNames).toContain("media-reviewer");
-      expect(skillNames).toContain("idea-synthesis");
-      expect(skillNames).toContain("writing-kit-assembler");
-    });
-
-    it("should return valid registry JSON schema", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-
-      // Check top-level structure
-      expect(result).toHaveProperty("plugins");
-      expect(result).toHaveProperty("summary");
-      expect(Array.isArray(result.plugins)).toBe(true);
-
-      // Check summary
-      expect(result.summary).toHaveProperty("totalPlugins");
-      expect(result.summary).toHaveProperty("totalSkills");
-      expect(typeof result.summary.totalPlugins).toBe("number");
-      expect(typeof result.summary.totalSkills).toBe("number");
-
-      // Check skill structure
-      const firstSkill = result.plugins[0]?.skills[0];
-      if (firstSkill) {
-        expect(firstSkill).toHaveProperty("name");
-        expect(firstSkill).toHaveProperty("description");
-        expect(firstSkill).toHaveProperty("capabilities");
-        expect(Array.isArray(firstSkill.capabilities)).toBe(true);
-      }
-    });
-
-    it("should include tools and model when specified", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-      const corePlugin = result.plugins.find((p) => p.name === "looplia-core");
-      const scanner = corePlugin?.skills.find(
-        (s) => s.name === "plugin-registry-scanner"
-      );
-
-      expect(scanner?.tools).toBeDefined();
-      expect(scanner?.tools).toContain("Bash");
-      expect(scanner?.model).toBe("claude-haiku-4-5-20251001");
-    });
-
-    it("should handle non-existent plugins directory gracefully", async () => {
-      const result = await scanPlugins("non-existent-dir");
-
-      expect(result.plugins).toEqual([]);
-      expect(result.summary.totalPlugins).toBe(0);
-      expect(result.summary.totalSkills).toBe(0);
-    });
-
-    it("should calculate correct totals", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-
-      const calculatedTotal = result.plugins.reduce(
-        (sum, p) => sum + p.skills.length,
-        0
-      );
-
-      expect(result.summary.totalSkills).toBe(calculatedTotal);
-      expect(result.summary.totalPlugins).toBe(result.plugins.length);
-    });
-
-    it("should discover exactly 15 skills after adding registry-loader", async () => {
-      const result = await scanPlugins(PLUGINS_DIR);
-
-      // After adding registry-loader skill, we should have all 15 skills
-      expect(result.summary.totalSkills).toBe(15);
-      expect(result.summary.totalPlugins).toBe(2);
-    });
-  });
-});