@looplia/looplia-cli 0.7.4 → 0.8.0

package/dist/{compiler-4B63UTUP-VE77VSJ2.js → compiler-QKB2ZYNK-CYEN6G5G.js}

@@ -12,13 +12,13 @@ import {
   loadSources,
   removeSource,
   saveSources
-} from "./chunk-XTUQVJYH.js";
-import "./chunk-VRBGWKZ6.js";
+} from "./chunk-MTYPUSCH.js";
+import "./chunk-326UJHZM.js";
 import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/compiler-4B63UTUP.js
+// ../../packages/provider/dist/compiler-QKB2ZYNK.js
 init_esm_shims();
 export {
   DEFAULT_MARKETPLACE_SOURCES,

package/dist/discovery-22DBV6CT.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env bun
+import {
+  getLoopliaPluginPath
+} from "./chunk-JJCGDGRS.js";
+import {
+  isValidPathSegment,
+  pathExists
+} from "./chunk-326UJHZM.js";
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/discovery/index.js
+init_esm_shims();
+import { mkdir, readdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var AUTO_DISCOVERY_PLUGIN_NAME = "auto-discovery-plugin";
+function getAutoDiscoveryPluginPath() {
+  return join(getLoopliaPluginPath(), "plugins", AUTO_DISCOVERY_PLUGIN_NAME);
+}
+async function ensureAutoDiscoveryPlugin() {
+  const pluginPath = getAutoDiscoveryPluginPath();
+  const pluginJsonPath = join(pluginPath, ".claude-plugin", "plugin.json");
+  const skillsDir = join(pluginPath, "skills");
+  if (await pathExists(join(pluginPath, ".claude-plugin"))) {
+    return;
+  }
+  await mkdir(join(pluginPath, ".claude-plugin"), { recursive: true });
+  await mkdir(skillsDir, { recursive: true });
+  const pluginJson = {
+    name: "auto-discovery-plugin",
+    description: "Auto-discovered skills from skills.sh registry",
+    version: "1.0.0",
+    author: { name: "Looplia" },
+    keywords: ["skills", "auto-discovery", "registry", "skills.sh"],
+    homepage: "https://github.com/memorysaver/looplia-core"
+  };
+  await writeFile(pluginJsonPath, JSON.stringify(pluginJson, null, 2), "utf-8");
+}
+async function installSkillToAutoDiscovery(skillName, skillContent, sourceUrl) {
+  if (!isValidPathSegment(skillName)) {
+    throw new Error(`Invalid skill name: ${skillName}`);
+  }
+  try {
+    await ensureAutoDiscoveryPlugin();
+    const skillDir = join(getAutoDiscoveryPluginPath(), "skills", skillName);
+    await mkdir(skillDir, { recursive: true });
+    const skillPath = join(skillDir, "SKILL.md");
+    await writeFile(skillPath, skillContent, "utf-8");
+    if (sourceUrl) {
+      const sourcePath = join(skillDir, "source.json");
+      await writeFile(
+        sourcePath,
+        JSON.stringify({ gitUrl: sourceUrl }, null, 2),
+        "utf-8"
+      );
+    }
+    return {
+      skill: skillName,
+      status: "installed",
+      path: skillDir
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skill: skillName,
+      status: "failed",
+      error: `Failed to install skill: ${message}`
+    };
+  }
+}
+async function listAutoDiscoveredSkills() {
+  const skillsDir = join(getAutoDiscoveryPluginPath(), "skills");
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function isSkillAutoDiscovered(skillName) {
+  if (!isValidPathSegment(skillName)) {
+    return false;
+  }
+  const skillDir = join(getAutoDiscoveryPluginPath(), "skills", skillName);
+  return await pathExists(skillDir);
+}
+var execFileAsync = promisify(execFile);
+var FORMAT1_PATTERN = /^(\S+)\s+-\s+(.+)\s+\(([^)]+)\)$/;
+var FORMAT2_PATTERN = /^([^/]+)\/([^\s]+)\s+-\s+(.+)$/;
+var FORMAT3_PATTERN = /^([^/\s]+)\/([^\s]+)$/;
+var FORMAT4_PATTERN = /^([^/\s]+)\/([^@\s]+)@([^\s]+)$/;
+var SKILL_SUFFIX_PATTERN = /-skill$/;
+var SKILL_PREFIX_PATTERN = /^skill-/;
+var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+var GITHUB_SEGMENT_PATTERN = /^[a-zA-Z0-9._-]+$/;
+async function searchSkills(query) {
+  try {
+    const { stdout } = await execFileAsync("npx", ["skills", "find", query], {
+      timeout: 3e4
+    });
+    return parseSkillsOutput(stdout);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Skills search failed: ${message}`);
+    console.warn("Continuing with local skills only");
+    return [];
+  }
+}
+function deriveSkillName(repo) {
+  return repo.replace(SKILL_SUFFIX_PATTERN, "").replace(SKILL_PREFIX_PATTERN, "");
+}
+function tryParseFormat1(line) {
+  const match = line.match(FORMAT1_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [, name, description, fullRepo] = match;
+  if (!(name && description && fullRepo)) {
+    return null;
+  }
+  const parts = fullRepo.split("/");
+  const owner = parts[0];
+  const repo = parts[1];
+  if (!(owner && repo)) {
+    return null;
+  }
+  return {
+    name,
+    description,
+    owner,
+    repo,
+    installCommand: `npx skills add ${fullRepo}`
+  };
+}
+function tryParseFormat2(line) {
+  const match = line.match(FORMAT2_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [, owner, repo, description] = match;
+  if (!(owner && repo && description)) {
+    return null;
+  }
+  return {
+    name: deriveSkillName(repo),
+    description,
+    owner,
+    repo,
+    installCommand: `npx skills add ${owner}/${repo}`
+  };
+}
+function tryParseFormat3(line) {
+  const match = line.match(FORMAT3_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [, owner, repo] = match;
+  if (!(owner && repo)) {
+    return null;
+  }
+  return {
+    name: deriveSkillName(repo),
+    description: "",
+    owner,
+    repo,
+    installCommand: `npx skills add ${owner}/${repo}`
+  };
+}
+function tryParseFormat4(line) {
+  const match = line.match(FORMAT4_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [, owner, repo, skillName] = match;
+  if (!(owner && repo && skillName)) {
+    return null;
+  }
+  return {
+    name: skillName,
+    description: "",
+    owner,
+    repo,
+    installCommand: `npx skills add ${owner}/${repo}@${skillName}`
+  };
+}
+function isValidGitHubSegment(s) {
+  return s.length > 0 && GITHUB_SEGMENT_PATTERN.test(s);
+}
+function stripAnsi(str) {
+  return str.replace(ANSI_PATTERN, "");
+}
+function parseSkillsOutput(output) {
+  const results = [];
+  const lines = output.split("\n").filter((line) => line.trim());
+  for (const rawLine of lines) {
+    const line = stripAnsi(rawLine);
+    const result = tryParseFormat4(line) ?? tryParseFormat1(line) ?? tryParseFormat2(line) ?? tryParseFormat3(line);
+    if (result) {
+      results.push(result);
+    }
+  }
+  return results;
+}
+async function fetchSkillContent(owner, repo, skillName) {
+  for (const [label, value] of [
+    ["owner", owner],
+    ["repo", repo],
+    ["skillName", skillName]
+  ]) {
+    if (!isValidGitHubSegment(value)) {
+      throw new Error(`Invalid ${label}: ${value}`);
+    }
+  }
+  const paths = [
+    `skills/${skillName}/SKILL.md`,
+    `${skillName}/SKILL.md`,
+    "SKILL.md"
+  ];
+  for (const path of paths) {
+    const url = `https://raw.githubusercontent.com/${owner}/${repo}/main/${path}`;
+    const response = await fetch(url);
+    if (response.ok) {
+      return response.text();
+    }
+  }
+  throw new Error(
+    `Failed to fetch skill content for ${owner}/${repo}/${skillName}`
+  );
+}
+export {
+  ensureAutoDiscoveryPlugin,
+  fetchSkillContent,
+  getAutoDiscoveryPluginPath,
+  installSkillToAutoDiscovery,
+  isSkillAutoDiscovered,
+  listAutoDiscoveredSkills,
+  searchSkills
+};

package/dist/{dist-LKL7WJ7K.js → dist-HMIWVZMJ.js}

@@ -11,11 +11,11 @@ import {
   loadCompiledRegistry,
   removeSkill,
   updateSkill
-} from "./chunk-XKLZXCWO.js";
+} from "./chunk-QKGHHAFR.js";
 import {
   syncRegistrySources,
   syncSource
-} from "./chunk-QQGRKUSM.js";
+} from "./chunk-3WLHRD63.js";
 import {
   addSource,
   compileRegistry,
@@ -27,13 +27,15 @@ import {
   loadSources,
   removeSource,
   saveSources
-} from "./chunk-XTUQVJYH.js";
+} from "./chunk-MTYPUSCH.js";
+import {
+  ensureWorkspace
+} from "./chunk-RAFHASLI.js";
 import {
   CORE_SKILLS,
-  ensureWorkspace,
   isCoreSkill
-} from "./chunk-PXCY2LDE.js";
-import "./chunk-VRBGWKZ6.js";
+} from "./chunk-JJCGDGRS.js";
+import "./chunk-326UJHZM.js";
 import "./chunk-Y55L47HC.js";
 export {
   CORE_SKILLS,

package/dist/{sync-E5PGFGNI-IGGJR7IL.js → sync-XZGFZXZF-6AWT77CE.js}

@@ -2,14 +2,14 @@
 import {
   syncRegistrySources,
   syncSource
-} from "./chunk-QQGRKUSM.js";
-import "./chunk-XTUQVJYH.js";
-import "./chunk-VRBGWKZ6.js";
+} from "./chunk-3WLHRD63.js";
+import "./chunk-MTYPUSCH.js";
+import "./chunk-326UJHZM.js";
 import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/sync-E5PGFGNI.js
+// ../../packages/provider/dist/sync-XZGFZXZF.js
 init_esm_shims();
 export {
   syncRegistrySources,

package/package.json

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

package/plugins/looplia-core/skills/workflow-executor/SKILL.md

@@ -26,6 +26,29 @@ Use this skill when:
 
 ---
 
+## ⚠️ CRITICAL EXECUTION MODEL - READ FIRST
+
+**YOU (the model reading this skill) must execute the step loop directly. DO NOT delegate.**
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  YOU (main agent) iterate through steps, making ONE Task call each  │
+│                                                                     │
+│  FOR step IN workflow.steps:                                        │
+│      1. Call Task(general-purpose) for THIS STEP ONLY               │
+│      2. WAIT for Task to complete                                   │
+│      3. Validate output                                             │
+│      4. THEN move to next step                                      │
+│                                                                     │
+│  ❌ WRONG: Task("Execute all workflow steps...")                    │
+│  ✅ RIGHT: Task("Execute step: summary"), Task("Execute step: ideas")│
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**3 steps = 3 Task calls. You MUST make 3 separate Task tool invocations.**
+
+---
+
 ## CRITICAL: Task Invocation with general-purpose Subagent
 
 **v0.6.9:** Using built-in `general-purpose` subagent for ALL workflow steps (all providers).
@@ -76,25 +99,37 @@ Each `Task(general-purpose)` creates a **separate context window**:
 
 **NEVER batch multiple steps** - this defeats context isolation.
 
-### Anti-Patterns
+### Anti-Patterns (VIOLATIONS = TEST FAILURE)
 
-❌ **WRONG - Delegating entire workflow:**
+❌ **FATAL ERROR - Delegating entire workflow to one Task:**
 ```json
 {
   "description": "Execute workflow: writing-kit",
   "prompt": "Run all workflow steps..."
 }
 ```
-This pollutes the subagent context with ALL steps.
+**This is WRONG.** You made 1 Task call. Tests expect 3. TEST WILL FAIL.
 
-✅ **CORRECT - One step per Task:**
-```json
-{
-  "description": "Execute step: summary",
-  "prompt": "Execute skill 'media-reviewer' for step 'summary'..."
-}
+❌ **FATAL ERROR - Executing skills inline without Task:**
 ```
-Each step gets a fresh, focused context window.
+Skill("media-reviewer")  // NO! You must use Task wrapper
+Skill("idea-synthesis")  // NO! You must use Task wrapper
+```
+**This is WRONG.** Each step MUST be wrapped in a Task call.
+
+✅ **CORRECT - One Task call per step (3 steps = 3 Task calls):**
+```
+Task("Execute step: summary")    // Task #1
+  → Subagent invokes Skill("media-reviewer")
+
+Task("Execute step: ideas")      // Task #2
+  → Subagent invokes Skill("idea-synthesis")
+
+Task("Execute step: writing-kit") // Task #3
+  → Subagent invokes Skill("writing-kit-assembler")
+```
+
+**Verification**: Count your Task tool calls. If workflow has 3 steps, you MUST have 3 Task calls.
 
 ---
 
@@ -243,18 +278,38 @@ Input:
 Computed order: [analyze-content, generate-ideas, build-writing-kit]
 ```
 
-### Phase 5: Step Execution Loop
+### Phase 5: Step Execution Loop (YOU MUST DO THIS)
+
+**YOU execute this loop. DO NOT delegate the loop to a subagent.**
 
-**Execute steps ONE AT A TIME (context isolation):**
+```
+YOU (main agent) must:
+┌────────────────────────────────────────────────────────────────┐
+│ for (const step of steps) {                                    │
+│   // 1. YOU call Task tool                                     │
+│   await Task({                                                 │
+│     subagent_type: "general-purpose",                          │
+│     description: `Execute step: ${step.id}`,                   │
+│     prompt: `Execute skill '${step.skill}' for step...`        │
+│   });                                                          │
+│                                                                │
+│   // 2. YOU wait for Task to complete                          │
+│   // 3. YOU validate output                                    │
+│   // 4. YOU update validation.json                             │
+│   // 5. YOU move to next step                                  │
+│ }                                                              │
+└────────────────────────────────────────────────────────────────┘
+```
 
+**Execution checklist:**
 1. Get first unvalidated step from dependency order
-2. Make ONE `Task(general-purpose)` call for THIS step only
-3. WAIT for Task completion before proceeding
-4. Validate output, update validation.json
-5. REPEAT for next unvalidated step
-6. STOP when ALL steps are validated
+2. **YOU** make ONE `Task(general-purpose)` call for THIS step only
+3. **YOU** WAIT for Task completion before proceeding
+4. **YOU** validate output, update validation.json
+5. **YOU** REPEAT for next unvalidated step
+6. **YOU** STOP when ALL steps are validated
 
-**MANDATORY:** Each step = separate context window = separate Task call.
+**MANDATORY:** 3 steps = 3 Task calls. Count them. If you made fewer, you did it wrong.
 
 ```
 FOR EACH step in dependency order: