@looplia/looplia-cli 0.6.9 → 0.7.0

package/dist/chunk-FCL2HRTX.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// ../../packages/provider/dist/chunk-MM63NAER.js
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdir, stat } from "fs/promises";
+var getFilename2 = () => fileURLToPath2(import.meta.url);
+var getDirname2 = () => path2.dirname(getFilename2());
+var __dirname2 = /* @__PURE__ */ getDirname2();
+async function pathExists(path22) {
+  try {
+    await stat(path22);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VALID_GIT_URL_PATTERN = /^https:\/\/(github\.com|gitlab\.com|bitbucket\.org)\/[\w.-]+\/[\w.-]+(\.git)?$/;
+var SHELL_INJECTION_PATTERN = /[;&|`$(){}[\]<>\\'"!\n\r]/;
+function isValidGitUrl(url) {
+  if (typeof url !== "string" || url.length === 0) {
+    return false;
+  }
+  if (SHELL_INJECTION_PATTERN.test(url)) {
+    return false;
+  }
+  return VALID_GIT_URL_PATTERN.test(url);
+}
+function isValidPathSegment(pathSegment) {
+  if (typeof pathSegment !== "string" || pathSegment.length === 0) {
+    return false;
+  }
+  if (pathSegment.includes("..")) {
+    return false;
+  }
+  if (pathSegment.startsWith("/")) {
+    return false;
+  }
+  if (pathSegment.includes("\0")) {
+    return false;
+  }
+  return true;
+}
+
+export {
+  __export,
+  __dirname,
+  __dirname2,
+  pathExists,
+  isValidGitUrl,
+  isValidPathSegment
+};

package/dist/chunk-GN6D7YWI.js

@@ -0,0 +1,580 @@
+#!/usr/bin/env node
+import {
+  pathExists
+} from "./chunk-FCL2HRTX.js";
+
+// ../../packages/provider/dist/chunk-NOF2J4UK.js
+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;
+    },
+    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 execAsync = promisify(exec);
+var OFFICIAL_REGISTRY_URL = "https://github.com/memorysaver/looplia-core/releases/latest/download/registry.json";
+var REGISTRY_SCHEMA_URL = "https://looplia.com/schema/registry.json";
+var REGISTRY_VERSION = "1.0.0";
+var PROTOCOL_REGEX = /^https?:\/\//;
+var TRAILING_SLASH_REGEX = /\/$/;
+var LEADING_DOT_SLASH_REGEX = /^\.\//;
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+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" }
+];
+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 = [
+      {
+        id: "official",
+        type: "official",
+        url: OFFICIAL_REGISTRY_URL,
+        enabled: true,
+        priority: 100,
+        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 {
+      $schema: REGISTRY_SCHEMA_URL,
+      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) {
+  if (source.type === "official") {
+    try {
+      const response = await fetch(source.url);
+      if (!response.ok) {
+        console.warn(
+          `Failed to fetch registry from ${source.url}: ${response.status}`
+        );
+        return null;
+      }
+      return {
+        manifest: await response.json(),
+        format: "registry"
+      };
+    } catch (error) {
+      console.warn(`Error fetching registry from ${source.url}:`, error);
+      return null;
+    }
+  }
+  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 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 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 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;
+  }
+}
+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(" ");
+}
+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: source.type === "official" ? "builtin" : "thirdparty",
+      installed: installed !== void 0,
+      installedPath: installed?.installedPath,
+      gitUrl: format === "marketplace" || source.type === "github" ? item.downloadUrl : void 0,
+      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(showProgress = false) {
+  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);
+  }
+  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 {
+    $schema: REGISTRY_SCHEMA_URL,
+    name: "looplia-official",
+    homepage: "https://github.com/memorysaver/looplia-core",
+    version: "0.7.0",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items: []
+  };
+}
+
+export {
+  createProgress,
+  getRegistryPath,
+  getCompiledRegistryPath,
+  getSkillCatalogPath,
+  getSourcesPath,
+  initializeRegistry,
+  loadSources,
+  saveSources,
+  addSource,
+  removeSource,
+  compileRegistry,
+  createEmptyManifest
+};