@looplia/looplia-cli 0.6.10 → 0.7.1

package/dist/chunk-5WPEFJ5J.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// src/utils/sandbox.ts
+init_esm_shims();
+import { randomBytes } from "crypto";
+import { mkdirSync } from "fs";
+import { join } from "path";
+var SANDBOX_DIRS = {
+  INPUTS: "inputs",
+  OUTPUTS: "outputs",
+  LOGS: "logs"
+};
+function generateRandomSuffix() {
+  return randomBytes(2).toString("hex");
+}
+function generateSlug(input, maxLength = 30) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").substring(0, maxLength);
+}
+function generateSandboxId(slug) {
+  const normalizedSlug = generateSlug(slug);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const suffix = generateRandomSuffix();
+  return `${normalizedSlug}-${date}-${suffix}`;
+}
+function createSandboxDirectories(workspace, sandboxId) {
+  const sandboxDir = join(workspace, "sandbox", sandboxId);
+  mkdirSync(join(sandboxDir, SANDBOX_DIRS.INPUTS), { recursive: true });
+  mkdirSync(join(sandboxDir, SANDBOX_DIRS.OUTPUTS), { recursive: true });
+  mkdirSync(join(sandboxDir, SANDBOX_DIRS.LOGS), { recursive: true });
+  return sandboxDir;
+}
+
+export {
+  SANDBOX_DIRS,
+  generateRandomSuffix,
+  generateSlug,
+  generateSandboxId,
+  createSandboxDirectories
+};

package/dist/chunk-APZNHRV3.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/claude-agent-sdk/index.js
+init_esm_shims();

package/dist/chunk-DN3RSIIJ.js

@@ -0,0 +1,595 @@
+#!/usr/bin/env bun
+import {
+  pathExists
+} from "./chunk-VRBGWKZ6.js";
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/chunk-M7EZUTK7.js
+init_esm_shims();
+import { exec } from "child_process";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+function createProgress() {
+  let currentMessage = "";
+  let isActive = false;
+  return {
+    start(message) {
+      currentMessage = message;
+      isActive = true;
+      process.stdout.write(`\u23F3 ${message}...`);
+    },
+    succeed(message) {
+      if (!isActive) {
+        return;
+      }
+      process.stdout.write("\r\x1B[K");
+      console.log(`\u2713 ${message ?? currentMessage}`);
+      isActive = false;
+    },
+    warn(message) {
+      if (!isActive) {
+        return;
+      }
+      process.stdout.write("\r\x1B[K");
+      console.log(`\u26A0 ${message ?? currentMessage}`);
+      isActive = false;
+    },
+    fail(message) {
+      if (!isActive) {
+        return;
+      }
+      process.stdout.write("\r\x1B[K");
+      console.log(`\u2717 ${message ?? currentMessage}`);
+      isActive = false;
+    },
+    update(message) {
+      if (!isActive) {
+        return;
+      }
+      currentMessage = message;
+      process.stdout.write(`\r\x1B[K\u23F3 ${message}...`);
+    },
+    stop() {
+      if (!isActive) {
+        return;
+      }
+      process.stdout.write("\r\x1B[K");
+      isActive = false;
+    }
+  };
+}
+var CAPABILITY_PATTERNS = [
+  { pattern: /media|video|audio|image/, capability: "media-processing" },
+  { pattern: /content|text|document/, capability: "content-analysis" },
+  { pattern: /json|schema|structured/, capability: "structured-output" },
+  { pattern: /workflow|orchestrat/, capability: "workflow-management" },
+  { pattern: /search|find|discover/, capability: "search" },
+  { pattern: /generat|creat|produc/, capability: "generation" },
+  { pattern: /valid|check|verify/, capability: "validation" }
+];
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+var PROTOCOL_REGEX = /^https?:\/\//;
+var TRAILING_SLASH_REGEX = /\/$/;
+var LEADING_DOT_SLASH_REGEX = /^\.\//;
+function parseMultilineValue(lines, startIndex) {
+  const multilineLines = [];
+  for (let j = startIndex; j < lines.length; j++) {
+    const nextLine = lines[j];
+    if (nextLine === void 0) {
+      break;
+    }
+    if (nextLine.startsWith("  ")) {
+      multilineLines.push(nextLine.trim());
+    } else if (nextLine.trim() !== "") {
+      break;
+    }
+  }
+  return multilineLines.join(" ");
+}
+function parseYamlFrontmatter(frontmatter) {
+  const lines = frontmatter.split("\n");
+  const metadata = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) {
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "|") {
+      value = parseMultilineValue(lines, i + 1);
+    }
+    metadata[key] = value;
+  }
+  return metadata;
+}
+function inferCategory(name, description) {
+  const text = `${name} ${description}`.toLowerCase();
+  if (text.includes("review") || text.includes("analyze") || text.includes("scan")) {
+    return "analysis";
+  }
+  if (text.includes("generate") || text.includes("synthesis") || text.includes("create")) {
+    return "generation";
+  }
+  if (text.includes("assemble") || text.includes("document") || text.includes("compile")) {
+    return "assembly";
+  }
+  if (text.includes("validate") || text.includes("check")) {
+    return "validation";
+  }
+  if (text.includes("search") || text.includes("find")) {
+    return "search";
+  }
+  if (text.includes("workflow") || text.includes("execute") || text.includes("orchestrat")) {
+    return "orchestration";
+  }
+  return "utility";
+}
+function inferCapabilities(description) {
+  const capabilities = [];
+  const text = description.toLowerCase();
+  for (const { pattern, capability } of CAPABILITY_PATTERNS) {
+    if (pattern.test(text)) {
+      capabilities.push(capability);
+    }
+  }
+  return capabilities;
+}
+function formatTitle(name) {
+  return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+var execAsync = promisify(exec);
+var REGISTRY_VERSION = "1.0.0";
+var DEFAULT_MARKETPLACE_SOURCES = [
+  {
+    name: "looplia-skills",
+    url: "https://github.com/memorysaver/looplia-skills",
+    description: "Looplia curated skills collection"
+  },
+  {
+    name: "anthropic-skills",
+    url: "https://github.com/anthropics/skills",
+    description: "Official Anthropic skills - xlsx, pdf, pptx, docx, frontend-design, and more"
+  },
+  {
+    name: "awesome-claude-skills",
+    url: "https://github.com/ComposioHQ/awesome-claude-skills",
+    description: "Community-curated Claude skills collection by ComposioHQ"
+  }
+];
+function getLoopliaHome() {
+  return process.env.LOOPLIA_HOME ?? join(homedir(), ".looplia");
+}
+function getRegistryPath() {
+  return join(getLoopliaHome(), "registry");
+}
+function getCompiledRegistryPath() {
+  return join(getRegistryPath(), "skill-catalog.json");
+}
+var getSkillCatalogPath = getCompiledRegistryPath;
+function getSourcesPath() {
+  return join(getRegistryPath(), "sources.json");
+}
+async function initializeRegistry(force = false) {
+  const registryPath = getRegistryPath();
+  const sourcesPath = getSourcesPath();
+  await mkdir(registryPath, { recursive: true });
+  await mkdir(join(registryPath, "cache"), { recursive: true });
+  if (force || !await pathExists(sourcesPath)) {
+    const defaultSources = DEFAULT_MARKETPLACE_SOURCES.map(
+      (source, index) => ({
+        id: `github:${source.url.replace("https://github.com/", "")}`,
+        type: "github",
+        url: source.url,
+        enabled: true,
+        priority: 90 - index * 10,
+        // First source gets highest priority
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    await writeFile(sourcesPath, JSON.stringify(defaultSources, null, 2));
+  }
+}
+async function loadSources() {
+  const sourcesPath = getSourcesPath();
+  if (!await pathExists(sourcesPath)) {
+    return [];
+  }
+  const content = await readFile(sourcesPath, "utf-8");
+  return JSON.parse(content);
+}
+async function saveSources(sources) {
+  const sourcesPath = getSourcesPath();
+  await writeFile(sourcesPath, JSON.stringify(sources, null, 2));
+}
+async function addSource(url, type = "github") {
+  const sources = await loadSources();
+  const normalizedPath = url.replace(PROTOCOL_REGEX, "").replace("github.com/", "").replace(TRAILING_SLASH_REGEX, "");
+  const id = type === "github" ? `github:${normalizedPath}` : `local:${url}`;
+  if (sources.some((s) => s.id === id)) {
+    throw new Error(`Source already exists: ${id}`);
+  }
+  const newSource = {
+    id,
+    type,
+    url,
+    enabled: true,
+    priority: 50,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  sources.push(newSource);
+  await saveSources(sources);
+  return newSource;
+}
+async function removeSource(sourceId) {
+  const sources = await loadSources();
+  const filtered = sources.filter((s) => s.id !== sourceId);
+  if (filtered.length === sources.length) {
+    return false;
+  }
+  await saveSources(filtered);
+  return true;
+}
+async function tryFetchMarketplace(repoPath) {
+  const url = `https://raw.githubusercontent.com/${repoPath}/main/.claude-plugin/marketplace.json`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return null;
+    }
+    const marketplace = await response.json();
+    const items = [];
+    for (const plugin of marketplace.plugins) {
+      for (const skillPath of plugin.skills) {
+        const skillName = skillPath.split("/").pop() ?? skillPath;
+        items.push({
+          name: skillName,
+          type: "registry:skill",
+          title: formatTitle(skillName),
+          description: `Skill from ${plugin.name}`,
+          author: plugin.name,
+          plugin: plugin.name,
+          category: inferCategory(skillName, plugin.description),
+          capabilities: inferCapabilities(plugin.description),
+          downloadUrl: `https://github.com/${repoPath}`,
+          files: [],
+          // Store skillPath for JIT installation
+          skillPath: skillPath.replace(LEADING_DOT_SLASH_REGEX, "")
+        });
+      }
+    }
+    return {
+      name: marketplace.name,
+      homepage: `https://github.com/${repoPath}`,
+      version: marketplace.version ?? "1.0.0",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      items
+    };
+  } catch {
+    return null;
+  }
+}
+async function tryFetchRegistryJson(repoPath) {
+  const url = `https://github.com/${repoPath}/releases/latest/download/registry.json`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchRemoteRegistry(source) {
+  const repoPath = source.url.replace(PROTOCOL_REGEX, "").replace("github.com/", "").replace(TRAILING_SLASH_REGEX, "");
+  const marketplaceManifest = await tryFetchMarketplace(repoPath);
+  if (marketplaceManifest) {
+    return { manifest: marketplaceManifest, format: "marketplace" };
+  }
+  const registryManifest = await tryFetchRegistryJson(repoPath);
+  if (registryManifest) {
+    return { manifest: registryManifest, format: "registry" };
+  }
+  console.warn(
+    `No registry found for ${source.url} (tried marketplace.json and registry.json)`
+  );
+  return null;
+}
+function buildSkillFromMetadata(metadata) {
+  const category = inferCategory(
+    metadata.name ?? "",
+    metadata.description ?? ""
+  );
+  const capabilities = inferCapabilities(metadata.description ?? "");
+  return {
+    name: metadata.name,
+    title: formatTitle(metadata.name ?? ""),
+    description: metadata.description ?? "",
+    category,
+    capabilities,
+    model: metadata.model,
+    inputless: metadata.inputless === "true",
+    tools: metadata.tools?.split(",").map((t) => t.trim())
+  };
+}
+async function parseSkillMetadata(skillPath) {
+  const skillMdPath = join(skillPath, "SKILL.md");
+  if (!await pathExists(skillMdPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(skillMdPath, "utf-8");
+    const frontmatterMatch = content.match(FRONTMATTER_REGEX);
+    if (!frontmatterMatch?.[1]) {
+      return null;
+    }
+    const metadata = parseYamlFrontmatter(frontmatterMatch[1]);
+    return buildSkillFromMetadata(metadata);
+  } catch {
+    return null;
+  }
+}
+async function getGitRemoteUrl(repoPath) {
+  const pluginJsonPath = join(repoPath, ".claude-plugin", "plugin.json");
+  try {
+    if (await pathExists(pluginJsonPath)) {
+      const content = await readFile(pluginJsonPath, "utf-8");
+      const pluginJson = JSON.parse(content);
+      if (pluginJson.source?.url) {
+        return pluginJson.source.url;
+      }
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execAsync("git remote get-url origin", {
+      cwd: repoPath
+    });
+    return stdout.trim() || void 0;
+  } catch {
+    return;
+  }
+}
+async function scanPluginDirectory(pluginPath, pluginName, sourceType) {
+  const skills = [];
+  const skillsPath = join(pluginPath, "skills");
+  if (!await pathExists(skillsPath)) {
+    return skills;
+  }
+  const gitUrl = sourceType === "thirdparty" ? await getGitRemoteUrl(pluginPath) : void 0;
+  try {
+    const skillEntries = await readdir(skillsPath, { withFileTypes: true });
+    for (const skillEntry of skillEntries) {
+      if (!skillEntry.isDirectory()) {
+        continue;
+      }
+      const skillPath = join(skillsPath, skillEntry.name);
+      const metadata = await parseSkillMetadata(skillPath);
+      if (metadata) {
+        skills.push({
+          name: metadata.name ?? skillEntry.name,
+          title: metadata.title ?? formatTitle(skillEntry.name),
+          description: metadata.description ?? "",
+          plugin: pluginName,
+          category: metadata.category ?? "utility",
+          capabilities: metadata.capabilities ?? [],
+          tools: metadata.tools,
+          model: metadata.model,
+          inputless: metadata.inputless,
+          source: "local",
+          sourceType,
+          installed: true,
+          installedPath: skillPath,
+          gitUrl
+        });
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function scanLocalPlugins(loopliaPath) {
+  const skills = [];
+  try {
+    const entries = await readdir(loopliaPath, { withFileTypes: true });
+    const builtinDirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "sandbox" && e.name !== "workflows" && e.name !== "registry" && e.name !== "plugins"
+    );
+    for (const pluginDir of builtinDirs) {
+      const pluginPath = join(loopliaPath, pluginDir.name);
+      const pluginSkills = await scanPluginDirectory(
+        pluginPath,
+        pluginDir.name,
+        "builtin"
+      );
+      skills.push(...pluginSkills);
+    }
+  } catch {
+  }
+  const pluginsDir = join(loopliaPath, "plugins");
+  if (await pathExists(pluginsDir)) {
+    try {
+      const entries = await readdir(pluginsDir, { withFileTypes: true });
+      const thirdPartyDirs = entries.filter(
+        (e) => e.isDirectory() && !e.name.startsWith(".")
+      );
+      for (const pluginDir of thirdPartyDirs) {
+        const pluginPath = join(pluginsDir, pluginDir.name);
+        const pluginSkills = await scanPluginDirectory(
+          pluginPath,
+          pluginDir.name,
+          "thirdparty"
+        );
+        skills.push(...pluginSkills);
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+async function processLocalSource(source, seenSkills, allSkills, progress) {
+  progress?.start(`Scanning local source: ${source.id}`);
+  try {
+    const localPath = source.url.startsWith("~") ? source.url.replace("~", homedir()) : source.url;
+    if (!await pathExists(localPath)) {
+      progress?.fail(`Local source not found: ${source.url}`);
+      return;
+    }
+    const skills = await scanPluginDirectory(
+      localPath,
+      source.id,
+      "thirdparty"
+    );
+    let addedCount = 0;
+    for (const skill of skills) {
+      if (seenSkills.has(skill.name)) {
+        continue;
+      }
+      skill.source = source.id;
+      allSkills.push(skill);
+      seenSkills.add(skill.name);
+      addedCount += 1;
+    }
+    progress?.succeed(`Scanned ${source.id}: ${addedCount} skills`);
+  } catch {
+    progress?.fail(`Failed to scan: ${source.id}`);
+  }
+}
+async function processRemoteSource(options) {
+  const { source, seenSkills, allSkills, installedSkillsMap, progress } = options;
+  progress?.start(`Fetching registry: ${source.id}`);
+  const result = await fetchRemoteRegistry(source);
+  if (!result) {
+    progress?.fail(`Failed to fetch: ${source.id}`);
+    return;
+  }
+  const { manifest, format } = result;
+  let addedCount = 0;
+  for (const item of manifest.items) {
+    if (seenSkills.has(item.name)) {
+      continue;
+    }
+    const installed = installedSkillsMap.get(item.name);
+    const skill = {
+      name: item.name,
+      title: item.title,
+      description: item.description,
+      plugin: item.plugin,
+      category: item.category,
+      capabilities: item.capabilities,
+      tools: item.tools,
+      model: item.model,
+      inputless: item.inputless,
+      source: source.id,
+      sourceType: "thirdparty",
+      installed: installed !== void 0,
+      installedPath: installed?.installedPath,
+      gitUrl: item.downloadUrl,
+      skillPath: item.skillPath,
+      // Set by marketplace format, undefined for registry.json
+      checksum: item.checksum,
+      dependencies: item.registryDependencies
+    };
+    allSkills.push(skill);
+    seenSkills.add(item.name);
+    addedCount += 1;
+  }
+  const formatLabel = format === "marketplace" ? "marketplace" : "registry";
+  progress?.succeed(
+    `Fetched ${source.id} (${formatLabel}): ${addedCount} skills`
+  );
+}
+function buildRegistrySummary(skills) {
+  const byCategory = {
+    analysis: 0,
+    generation: 0,
+    assembly: 0,
+    validation: 0,
+    search: 0,
+    orchestration: 0,
+    utility: 0
+  };
+  const bySource = {};
+  for (const skill of skills) {
+    byCategory[skill.category] += 1;
+    bySource[skill.source] = (bySource[skill.source] ?? 0) + 1;
+  }
+  return { byCategory, bySource };
+}
+async function compileRegistry(options) {
+  const { showProgress = false, localOnly = true } = options ?? {};
+  const progress = showProgress ? createProgress() : null;
+  const loopliaPath = getLoopliaHome();
+  const sources = await loadSources();
+  progress?.start("Scanning local plugins");
+  const localSkills = await scanLocalPlugins(loopliaPath);
+  const installedSkillsMap = new Map(localSkills.map((s) => [s.name, s]));
+  progress?.succeed(`Found ${localSkills.length} local skills`);
+  const allSkills = [...localSkills];
+  const seenSkills = new Set(localSkills.map((s) => s.name));
+  const localSources = sources.filter((s) => s.enabled && s.type === "local");
+  for (const source of localSources) {
+    await processLocalSource(source, seenSkills, allSkills, progress);
+  }
+  if (!localOnly) {
+    const remoteSources = sources.filter((s) => s.enabled && s.type !== "local").sort((a, b) => b.priority - a.priority);
+    for (const source of remoteSources) {
+      await processRemoteSource({
+        source,
+        seenSkills,
+        allSkills,
+        installedSkillsMap,
+        progress
+      });
+    }
+  }
+  const { byCategory, bySource } = buildRegistrySummary(allSkills);
+  const compiled = {
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: REGISTRY_VERSION,
+    sources,
+    skills: allSkills,
+    summary: { totalSkills: allSkills.length, byCategory, bySource }
+  };
+  const registryPath = getRegistryPath();
+  await mkdir(registryPath, { recursive: true });
+  await writeFile(getCompiledRegistryPath(), JSON.stringify(compiled, null, 2));
+  return compiled;
+}
+function createEmptyManifest() {
+  return {
+    name: "looplia",
+    homepage: "https://github.com/memorysaver/looplia-core",
+    version: "0.7.1",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items: []
+  };
+}
+
+export {
+  createProgress,
+  FRONTMATTER_REGEX,
+  PROTOCOL_REGEX,
+  TRAILING_SLASH_REGEX,
+  DEFAULT_MARKETPLACE_SOURCES,
+  getRegistryPath,
+  getCompiledRegistryPath,
+  getSkillCatalogPath,
+  getSourcesPath,
+  initializeRegistry,
+  loadSources,
+  saveSources,
+  addSource,
+  removeSource,
+  compileRegistry,
+  createEmptyManifest
+};