@looplia/looplia-cli 0.6.10 → 0.7.1

package/dist/dist-5SEP7KKQ.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+import {
+  ensureWorkflowSkills,
+  findSkill,
+  getAvailableSkills,
+  getInstalledSkills,
+  getSkillsByCategory,
+  getSkillsBySource,
+  installSkill,
+  installSkillFromUrl,
+  loadCompiledRegistry,
+  removeSkill,
+  updateSkill
+} from "./chunk-2TWYHMFD.js";
+import {
+  syncRegistrySources,
+  syncSource
+} from "./chunk-NUQVUYOZ.js";
+import {
+  addSource,
+  compileRegistry,
+  getCompiledRegistryPath,
+  getRegistryPath,
+  getSkillCatalogPath,
+  getSourcesPath,
+  initializeRegistry,
+  loadSources,
+  removeSource,
+  saveSources
+} from "./chunk-DN3RSIIJ.js";
+import {
+  CORE_SKILLS,
+  ensureWorkspace,
+  isCoreSkill
+} from "./chunk-HSZZVXV5.js";
+import "./chunk-VRBGWKZ6.js";
+import "./chunk-Y55L47HC.js";
+export {
+  CORE_SKILLS,
+  addSource,
+  compileRegistry,
+  ensureWorkflowSkills,
+  ensureWorkspace,
+  findSkill,
+  getAvailableSkills,
+  getCompiledRegistryPath,
+  getInstalledSkills,
+  getRegistryPath,
+  getSkillCatalogPath,
+  getSkillsByCategory,
+  getSkillsBySource,
+  getSourcesPath,
+  initializeRegistry,
+  installSkill,
+  installSkillFromUrl,
+  isCoreSkill,
+  loadCompiledRegistry,
+  loadSources,
+  removeSkill,
+  removeSource,
+  saveSources,
+  syncRegistrySources,
+  syncSource,
+  updateSkill
+};

package/dist/sandbox-HAMJNBZ6.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+import {
+  SANDBOX_DIRS,
+  createSandboxDirectories,
+  generateRandomSuffix,
+  generateSandboxId,
+  generateSlug
+} from "./chunk-5WPEFJ5J.js";
+import "./chunk-Y55L47HC.js";
+export {
+  SANDBOX_DIRS,
+  createSandboxDirectories,
+  generateRandomSuffix,
+  generateSandboxId,
+  generateSlug
+};

package/dist/sync-MXQ4NJWI-KGAZYCPW.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import {
+  syncRegistrySources,
+  syncSource
+} from "./chunk-NUQVUYOZ.js";
+import "./chunk-DN3RSIIJ.js";
+import "./chunk-VRBGWKZ6.js";
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/sync-MXQ4NJWI.js
+init_esm_shims();
+export {
+  syncRegistrySources,
+  syncSource
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looplia/looplia-cli",
-  "version": "0.6.10",
+  "version": "0.7.1",
   "description": "Looplia CLI - AI-powered workflow automation tool",
   "type": "module",
   "license": "Elastic-2.0",

package/plugins/looplia-core/skills/registry-loader/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: registry-loader
+description: |
+  Load the skill catalog for workflow building. This skill should be used when
+  discovering available looplia skills or listing what capabilities are available. Use when
+  someone says "what looplia skills are installed", "list available skills", "/build",
+  "what can looplia do", or "show me all looplia capabilities".
+
+  v0.7.0: Replaces plugin-registry-scanner with skill catalog for faster access.
+  Auto-syncs from all sources on every build to ensure freshest skill catalog.
+tools: Read
+model: haiku
+---
+
+# Registry Loader
+
+Load the skill catalog for workflow building and skill discovery.
+
+## Purpose
+
+Provides fast access to the skill catalog for the build pipeline.
+Uses the pre-compiled `~/.looplia/registry/skill-catalog.json` instead of runtime scanning.
+
+## Behavior
+
+1. Read the skill catalog from `~/.looplia/registry/skill-catalog.json`
+2. If catalog doesn't exist, return empty registry with instructions to run `looplia registry sync`
+3. Return catalog data for skill-capability-matcher
+
+## Process
+
+### 1. Load Skill Catalog
+
+Read the skill catalog file:
+
+```bash
+cat ~/.looplia/registry/skill-catalog.json
+```
+
+Or use the Read tool to access the file directly.
+
+### 2. Parse Catalog Data
+
+The skill catalog contains:
+
+```json
+{
+  "compiledAt": "2026-01-04T12:00:00Z",
+  "version": "1.0.0",
+  "sources": [
+    {
+      "id": "official",
+      "type": "official",
+      "url": "https://github.com/memorysaver/looplia-core/releases/latest/download/registry.json",
+      "enabled": true,
+      "priority": 100
+    }
+  ],
+  "skills": [
+    {
+      "name": "media-reviewer",
+      "title": "Media Reviewer",
+      "description": "Deep content analysis (structure, themes, narrative)",
+      "plugin": "looplia-writer",
+      "category": "analysis",
+      "capabilities": ["content-analysis", "media-processing"],
+      "tools": ["Read", "Grep", "Glob"],
+      "model": "claude-haiku-4-5-20251001",
+      "source": "local",
+      "sourceType": "builtin",
+      "installed": true,
+      "installedPath": "/home/user/.looplia/looplia-writer/skills/media-reviewer"
+    }
+  ],
+  "summary": {
+    "totalSkills": 14,
+    "byCategory": {
+      "analysis": 3,
+      "generation": 2,
+      "assembly": 2,
+      "validation": 1,
+      "search": 1,
+      "orchestration": 3,
+      "utility": 2
+    },
+    "bySource": {
+      "local": 14
+    }
+  }
+}
+```
+
+### 3. Format for skill-capability-matcher
+
+Transform the skill catalog into the format expected by skill-capability-matcher:
+
+```json
+{
+  "plugins": [
+    {
+      "name": "looplia-writer",
+      "path": "~/.looplia/looplia-writer",
+      "skills": [
+        {
+          "name": "media-reviewer",
+          "description": "Deep content analysis (structure, themes, narrative)",
+          "tools": ["Read", "Grep", "Glob"],
+          "model": "haiku",
+          "capabilities": ["content-analysis", "media-processing"],
+          "installed": true
+        }
+      ]
+    }
+  ],
+  "summary": {
+    "totalPlugins": 2,
+    "totalSkills": 14,
+    "installedSkills": 14,
+    "availableSkills": 0
+  }
+}
+```
+
+## Output Schema
+
+```json
+{
+  "plugins": [
+    {
+      "name": "string",
+      "path": "string",
+      "skills": [
+        {
+          "name": "string",
+          "description": "string",
+          "tools": ["string"],
+          "model": "string",
+          "capabilities": ["string"],
+          "installed": "boolean"
+        }
+      ]
+    }
+  ],
+  "summary": {
+    "totalPlugins": "number",
+    "totalSkills": "number",
+    "installedSkills": "number",
+    "availableSkills": "number"
+  }
+}
+```
+
+## Advantages over plugin-registry-scanner
+
+| Aspect | plugin-registry-scanner | registry-loader (v0.7.0) |
+|--------|------------------------|--------------------------|
+| Speed | Scans filesystem at runtime | Reads pre-compiled JSON |
+| Sources | Local only | Official + third-party |
+| Installation Status | Not tracked | Included in output |
+| Third-party Skills | Not discovered | Included from remote registries |
+
+## Usage
+
+This skill is typically invoked as the first step in workflow building:
+
+1. Load skill catalog (this skill)
+2. Pass catalog to skill-capability-matcher
+3. Use matched skills in workflow-schema-composer
+
+## Notes
+
+- If skill catalog doesn't exist, advise user to run `looplia registry sync`
+- Catalog is auto-synced on every `looplia build` command
+- Includes installation status for each skill
+- Third-party skills may show `installed: false` until installed via `looplia skill add`

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

@@ -16,7 +16,7 @@ description: |
   - 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
+model: haiku
 tools:
   - Glob
   - Grep

package/plugins/looplia-core/skills/skill-capability-matcher/SKILL.md

@@ -1,15 +1,19 @@
 ---
 name: skill-capability-matcher
 description: |
-  This skill should be used when the user wants to find the right looplia skills for a task,
-  match requirements to available capabilities, or determine which skills should handle each
-  workflow step. Use when someone says "which looplia skill handles X", "find skills for this
-  task", "match my requirements to skills", or "/build" (after registry scan).
+  This skill should be used when matching user requirements to available skills from a
+  compiled registry. It receives a skill registry (from registry-loader) and user requirements,
+  then scores each skill based on capability alignment, producing prioritized matches with
+  confidence scores.
 
-  Second step in looplia workflow building: takes user requirements and skill registry,
+  Triggers: "match skills to requirements", "find relevant skills for workflow", "which skill
+  handles X", "score skill capabilities", "/build" (after registry load), "find skills for
+  this task", "match my requirements to skills".
+
+  Second step in looplia workflow building pipeline: takes user requirements and skill registry,
   recommends skill sequences with missions. Designs one workflow step → one skill-executor
   → multiple skills orchestration pattern.
-model: claude-haiku-4-5-20251001
+model: haiku
 ---
 
 # Skill Capability Matcher
@@ -50,16 +54,17 @@ Extract from the user's description:
 
 ### Step 2: Load Registry
 
-Read the plugin registry from plugin-registry-scanner output:
+Read the plugin registry from registry-loader output (v0.7.0):
 
 ```json
 {
   "plugins": [...],
-  "summary": { "totalSkills": N }
+  "summary": { "totalSkills": N, "installedSkills": N, "availableSkills": N }
 }
 ```
 
 Build a capability index from skill descriptions and inferred capabilities.
+Include `installed` status when scoring - prefer installed skills for immediate execution.
 
 ### Step 3: Match Capabilities
 
@@ -232,6 +237,69 @@ Provide:
 | Weak/inferred match | 0.3-0.5 |
 | No clear match | < 0.3 |
 
+## Scoring Rubric
+
+Use these concrete criteria when assigning scores:
+
+### Relevance Score (Primary Factor)
+- **90-100**: Skill's primary purpose directly addresses requirement
+- **70-89**: Skill clearly capable of addressing requirement
+- **50-69**: Skill partially addresses requirement
+- **30-49**: Skill tangentially related
+- **0-29**: Minimal or no relevance
+
+### Completeness Score
+- **90-100**: Skill fully addresses all aspects of requirement
+- **70-89**: Skill addresses most aspects, minor gaps
+- **50-69**: Skill addresses core need, notable gaps
+- **Below 50**: Significant portions unaddressed
+
+### Specificity Score
+- **90-100**: Skill specifically designed for this exact use case
+- **70-89**: Skill well-suited for use case category
+- **50-69**: General-purpose skill applicable to use case
+- **Below 50**: Very general skill with broad applicability
+
+### Confidence Calculation
+
+```
+confidence = (relevance * 0.5) + (completeness * 0.3) + (specificity * 0.2)
+```
+
+**Minimum threshold: 60%** - Skills below this should not be recommended.
+
+## Semantic Matching Guidelines
+
+Match requirements to skills beyond simple keyword matching:
+
+### 1. Synonym Recognition
+Match conceptually equivalent terms:
+- "authentication" ↔ "login", "session management", "user verification"
+- "database" ↔ "data persistence", "storage", specific ORMs
+- "analyze" ↔ "review", "examine", "inspect", "assess"
+- "generate" ↔ "create", "produce", "synthesize", "build"
+
+### 2. Hierarchical Matching
+Understand skill scope and specificity:
+- General skill may satisfy specific requirement (e.g., "api-client" for "REST calls")
+- Prefer specific skill over general when available (e.g., "stripe-integration" over "payment-api")
+
+### 3. Intent Extraction
+Focus on what user wants to accomplish, not just keywords:
+- "I need to send emails" → match email/notification skills
+- "Process video content" → match media-reviewer, not just skills with "video" in name
+- "Build a report from data" → match assembly/documentation skills
+
+## Edge Cases
+
+| Scenario | Handling |
+|----------|----------|
+| No matches above 60% threshold | Return empty `recommendations[]` with `gaps` listing unmet needs |
+| Multiple skills with identical scores | Prefer more specific skill (higher specificity score) |
+| Ambiguous user requirements | Set `clarificationNeeded: true` with targeted questions |
+| Skill matches multiple requirements | Include once with highest-scoring requirement as primary |
+| Installed vs available skills | Prefer installed skills when scores are within 10% |
+
 ## Mission Writing Guidelines
 
 Each mission should:

package/plugins/looplia-core/skills/workflow-schema-composer/SKILL.md

@@ -6,12 +6,13 @@ description: |
   someone says "create a looplia workflow", "generate workflow.md", "compose workflow steps",
   "build me an automation pipeline", or "/build" (final step).
 
-  Final step in looplia workflow building: transforms skill recommendations into valid v0.6.3
+  Final step in looplia workflow building: transforms skill recommendations into valid v0.7.0
   workflow YAML/Markdown files. Each step uses skill: + mission: syntax, following the one
   workflow step → one skill-executor → multiple skills architecture.
 
+  v0.7.0: Generates explicit `skills:` declaration for selective plugin loading.
   v0.6.3: Supports input-less workflows using input-less capable skills (e.g., search).
-model: claude-haiku-4-5-20251001
+model: haiku
 ---
 
 # Workflow Schema Composer
@@ -122,7 +123,7 @@ Based on skill output type:
 - Idea skills: `required_fields: [contentId, hooks, angles]`
 - Assembly skills: `required_fields: [contentId, suggestedOutline]`
 
-### Step 6: Compose Frontmatter
+### Step 6: Compose Frontmatter (v0.7.0)
 
 **CRITICAL: If `--name` flag was provided, use that exact name. Do not derive or modify it.**
 
@@ -132,15 +133,26 @@ name: {explicit-name OR derived-from-description}
 version: 1.0.0
 description: {user's original description, cleaned up}
 
+# v0.7.0: Explicit skills declaration for selective plugin loading
+skills:
+  - {skill-name-1}
+  - {skill-name-2}
+  - ...
+
 steps:
   - id: ...
 ---
 ```
 
+**Skills Declaration (v0.7.0):**
+Extract unique skill names from all step recommendations and list them in the `skills:` field.
+This enables selective plugin loading at runtime - only required skills are loaded.
+
 Naming rules:
 1. If `--name article-summary` was provided → use `article-summary` exactly
 2. If no `--name` → derive from description (e.g., "analyze videos" → "video-analyzer")
 3. Always use kebab-case for names
+4. Always include `skills:` field with all unique skills from steps
 
 ### Step 7: Generate Markdown Body
 
@@ -216,6 +228,12 @@ name: video-to-blog
 version: 1.0.0
 description: Analyze YouTube videos and create blog outlines
 
+# v0.7.0: Explicit skills declaration for selective plugin loading
+skills:
+  - media-reviewer
+  - idea-synthesis
+  - writing-kit-assembler
+
 steps:
   - id: analyze-content
     skill: media-reviewer
@@ -281,6 +299,7 @@ looplia run video-to-blog --file <transcript.md>
 6. **Respect --name flag** - If `--name X` is provided, the workflow MUST be named `X` and saved as `X.md`
 7. **Detect input-less workflows** - If first step uses `search` skill, OMIT input field
 8. **Incorporate user preferences (v0.6.4)** - Extract preferences from "User clarifications" and inject into step missions. Each preference MUST appear in at least one mission.
+9. **Include skills declaration (v0.7.0)** - Always add `skills:` field listing all unique skill names from steps. This enables selective plugin loading at runtime.
 
 ## Example: Input-Less Workflow (v0.6.3)
 
@@ -292,6 +311,11 @@ name: daily-news-digest
 version: 1.0.0
 description: Fetch trending news and compile a digest report
 
+# v0.7.0: Explicit skills declaration
+skills:
+  - search
+  - content-documenter
+
 steps:
   - id: fetch-news
     skill: search

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