@looplia/looplia-cli 0.6.6

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

@@ -0,0 +1,221 @@
+#!/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

@@ -0,0 +1,256 @@
+import { describe, expect, it } from "bun:test";
+import {
+  CAPABILITY_PATTERNS,
+  extractFrontmatter,
+  inferCapabilities,
+  scanPlugins,
+} from "../scripts/scan-plugins";
+
+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");
+      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");
+      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");
+
+      // 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");
+      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");
+
+      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 14 skills after adding workflow-executor-inline", async () => {
+      const result = await scanPlugins("plugins");
+
+      // After adding workflow-executor-inline skill, we should have all 14 skills
+      expect(result.summary.totalSkills).toBe(14);
+      expect(result.summary.totalPlugins).toBe(2);
+    });
+  });
+});

package/plugins/looplia-core/skills/search/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: search
+description: |
+  This skill should be used when the user needs to search for information, find files,
+  look up content online, or retrieve data without providing input files.
+
+  Trigger phrases include:
+  - "search for", "find", "look up", "research"
+  - "search the web", "search online", "fetch from URL"
+  - "search files", "scan codebase", "find in project", "grep for"
+  - "get news from", "read hacker news", "check what's trending"
+
+  Supports multiple search modes:
+  - local: Search local filesystem using Glob, Grep, Read, Bash
+  - web: Search web content using WebSearch, WebFetch
+  - future: Pluggable providers (jina.ai, firecrawl, exa.ai)
+
+  This is an input-less skill - it executes search missions autonomously.
+model: claude-haiku-4-5-20251001
+tools:
+  - Glob
+  - Grep
+  - Read
+  - Bash
+  - WebSearch
+  - WebFetch
+---
+
+# Search Skill
+
+Execute search missions and compile structured results from various sources.
+
+## Purpose
+
+Provide a unified search interface that can:
+1. Search local files, codebases, and directories
+2. Search web content (via WebSearch/WebFetch or future provider integrations)
+3. Compile results into structured JSON output
+
+This skill operates **without user-provided input files** - it receives a search mission and executes it autonomously.
+
+## Search Modes
+
+### Local Mode
+
+Search the local environment:
+
+| Tool | Use Case |
+|------|----------|
+| `Glob` | Find files by pattern (e.g., `**/*.md`, `src/**/*.ts`) |
+| `Grep` | Search file contents for patterns |
+| `Read` | Read matched files for content extraction |
+| `Bash` | Execute find, ls, or other search commands |
+
+### Web Mode
+
+Search web content:
+
+| Tool | Use Case |
+|------|----------|
+| `WebSearch` | Search the web for topics, news, documentation |
+| `WebFetch` | Fetch and extract content from URLs |
+
+**Future Providers** (planned integration):
+- `jina.ai` - AI-powered web search and extraction
+- `firecrawl` - Web crawling and scraping
+- `exa.ai` - Neural search engine
+
+## Process
+
+### Step 1: Parse Mission
+
+Extract from the mission description:
+- **Search target**: What to search for (keywords, patterns, topics)
+- **Search mode**: local, web, or auto-detect
+- **Scope**: Directories, file types, domains, date range
+- **Compile format**: How to structure results
+
+### Step 2: Execute Search
+
+Based on mode:
+
+**Local:**
+```
+1. Use Glob to find matching files
+2. Use Grep to search content patterns
+3. Use Read to extract relevant sections
+4. Compile matched results
+```
+
+**Web:**
+```
+1. Use WebSearch to find relevant pages
+2. Use WebFetch to extract content
+3. Parse and filter results
+4. Compile into structured format
+```
+
+### Step 3: Compile Results
+
+Structure findings into the output schema with:
+- Source attribution (file path or URL)
+- Relevance scoring
+- Extracted content snippets
+- Metadata (date, author if available)
+
+## Input
+
+The skill receives a **mission description** specifying:
+- What to search for
+- Where to search (mode/scope)
+- What to extract and compile
+
+Example missions:
+```
+Search for all TODO comments in the src/ directory and compile a list with file locations.
+```
+```
+Search Hacker News for the top 5 trending AI stories today and summarize each.
+```
+```
+Find all TypeScript files that import from '@looplia-core/core' and list their exports.
+```
+
+## Output Schema
+
+```json
+{
+  "query": "original search query/mission",
+  "mode": "local | web",
+  "results": [
+    {
+      "source": "path/to/file.ts | https://example.com/page",
+      "type": "file | url",
+      "title": "Optional title or filename",
+      "content": "Extracted content or snippet",
+      "relevance": 0.95,
+      "metadata": {
+        "lineNumber": 42,
+        "matchContext": "surrounding context",
+        "date": "2025-12-24",
+        "author": "optional"
+      }
+    }
+  ],
+  "summary": "Brief summary of findings",
+  "totalMatches": 15,
+  "compiledAt": "2025-12-24T10:30:00Z"
+}
+```
+
+## Usage in Workflows
+
+This skill enables **input-less workflow steps**:
+
+```yaml
+steps:
+  - id: find-news
+    skill: search
+    mission: |
+      Search Hacker News for today's top 3 AI stories.
+      Extract title, URL, points, and brief summary for each.
+    output: outputs/news.json
+```
+
+No `input:` field required - the skill operates autonomously.
+
+## Important Rules
+
+1. **Always attribute sources** - Include file paths or URLs for all results
+2. **Respect scope** - Only search within specified boundaries
+3. **Compile, don't dump** - Structure results, don't return raw search output
+4. **Handle empty results** - Return valid JSON even when no matches found
+5. **Rate limit web searches** - Be mindful of API limits for web providers