@looplia/looplia-cli 0.7.4 → 0.8.0

package/dist/{chunk-VRBGWKZ6.js → chunk-326UJHZM.js}

@@ -3,7 +3,7 @@ import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-MM63NAER.js
+// ../../packages/provider/dist/chunk-ZVGA4TFN.js
 init_esm_shims();
 import path from "path";
 import { fileURLToPath } from "url";

package/dist/{chunk-QQGRKUSM.js → chunk-3WLHRD63.js}

@@ -5,17 +5,17 @@ import {
   TRAILING_SLASH_REGEX,
   createProgress,
   loadSources
-} from "./chunk-XTUQVJYH.js";
+} from "./chunk-MTYPUSCH.js";
 import {
   isValidGitUrl,
   isValidPathSegment,
   pathExists
-} from "./chunk-VRBGWKZ6.js";
+} from "./chunk-326UJHZM.js";
 import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-O57P5VMU.js
+// ../../packages/provider/dist/chunk-AOIDFPNW.js
 init_esm_shims();
 import { exec } from "child_process";
 import { cp, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";

package/dist/chunk-JJCGDGRS.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env bun
+import {
+  __dirname,
+  pathExists
+} from "./chunk-326UJHZM.js";
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/chunk-WLNOVOST.js
+init_esm_shims();
+import { createHash } from "crypto";
+import {
+  cp,
+  mkdir as mkdir2,
+  readdir as readdir2,
+  readFile,
+  realpath,
+  rm,
+  writeFile
+} from "fs/promises";
+import { homedir as homedir2, tmpdir } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { exec } from "child_process";
+import { mkdir, readdir } from "fs/promises";
+import { join } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var CORE_SKILLS = [
+  "workflow-executor",
+  "workflow-validator",
+  "registry-loader"
+];
+async function buildSkillPluginMap(pluginPaths) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { path: pluginPath } of pluginPaths) {
+    const skillsDir = join(pluginPath, "skills");
+    if (!await pathExists(skillsDir)) {
+      continue;
+    }
+    try {
+      const entries = await readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          map.set(entry.name, pluginPath);
+        }
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+async function getSelectivePluginPaths(requiredSkills) {
+  const allPluginPaths = await getPluginPaths();
+  if (!requiredSkills || requiredSkills.length === 0) {
+    return allPluginPaths;
+  }
+  const neededSkills = /* @__PURE__ */ new Set([...CORE_SKILLS, ...requiredSkills]);
+  const skillToPlugin = await buildSkillPluginMap(allPluginPaths);
+  const pluginsToLoad = /* @__PURE__ */ new Set();
+  for (const skill of neededSkills) {
+    const pluginPath = skillToPlugin.get(skill);
+    if (pluginPath) {
+      pluginsToLoad.add(pluginPath);
+    }
+  }
+  return allPluginPaths.filter((p) => pluginsToLoad.has(p.path));
+}
+function isCoreSkill(skillName) {
+  return CORE_SKILLS.includes(skillName);
+}
+async function computeSha256(filePath) {
+  const content = await readFile(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+async function validateExtractedPaths(baseDir) {
+  const realBase = await realpath(baseDir);
+  const entries = await readdir2(baseDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(baseDir, entry.name);
+    const entryRealPath = await realpath(fullPath);
+    if (!entryRealPath.startsWith(realBase)) {
+      throw new Error(
+        `Security: Path traversal detected in extracted file: ${entry.name}`
+      );
+    }
+    if (entry.isDirectory()) {
+      await validateExtractedPaths(fullPath);
+    }
+  }
+}
+function getLoopliaPluginPath() {
+  return process.env.LOOPLIA_HOME ?? join2(homedir2(), ".looplia");
+}
+function getBundledPluginsPath() {
+  const currentFile = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+  return join2(currentFile, "..", "..", "plugins");
+}
+async function parseMarketplace(marketplacePath) {
+  const content = await readFile(marketplacePath, "utf-8");
+  return JSON.parse(content);
+}
+async function getPluginNamesFromSource(bundledPath) {
+  const marketplacePath = join2(
+    bundledPath,
+    "..",
+    ".claude-plugin",
+    "marketplace.json"
+  );
+  if (await pathExists(marketplacePath)) {
+    const marketplace = await parseMarketplace(marketplacePath);
+    return marketplace.plugins.map((p) => {
+      const parts = p.source.split("/");
+      return parts.at(-1);
+    }).filter((name) => name !== void 0);
+  }
+  const entries = await readdir2(bundledPath, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+}
+function createDefaultProfile() {
+  return {
+    userId: "default",
+    topics: [],
+    style: {
+      tone: "intermediate",
+      targetWordCount: 1e3,
+      voice: "first-person"
+    }
+  };
+}
+async function extractWorkflows(targetDir, pluginsDir, pluginNames) {
+  const workflowsDir = join2(targetDir, "workflows");
+  await mkdir2(workflowsDir, { recursive: true });
+  for (const pluginName of pluginNames) {
+    const pluginWorkflowsPath = join2(pluginsDir, pluginName, "workflows");
+    if (!await pathExists(pluginWorkflowsPath)) {
+      continue;
+    }
+    const entries = await readdir2(pluginWorkflowsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        await cp(
+          join2(pluginWorkflowsPath, entry.name),
+          join2(workflowsDir, entry.name)
+        );
+      }
+    }
+    await rm(pluginWorkflowsPath, { recursive: true, force: true });
+  }
+}
+async function copyPlugins(targetDir, sourcePath) {
+  const bundledPath = sourcePath ?? getBundledPluginsPath();
+  const pluginNames = await getPluginNamesFromSource(bundledPath);
+  if (pluginNames.length === 0) {
+    throw new Error(`No plugins found at ${bundledPath}`);
+  }
+  if (await pathExists(targetDir)) {
+    await rm(targetDir, { recursive: true, force: true });
+  }
+  await mkdir2(targetDir, { recursive: true });
+  const pluginsDir = join2(targetDir, "plugins");
+  await mkdir2(pluginsDir, { recursive: true });
+  for (const pluginName of pluginNames) {
+    const pluginPath = join2(bundledPath, pluginName);
+    if (await pathExists(pluginPath)) {
+      await cp(pluginPath, join2(pluginsDir, pluginName), { recursive: true });
+    }
+  }
+  await extractWorkflows(targetDir, pluginsDir, pluginNames);
+  await mkdir2(join2(targetDir, "sandbox"), { recursive: true });
+  await writeFile(
+    join2(targetDir, "user-profile.json"),
+    JSON.stringify(createDefaultProfile(), null, 2),
+    "utf-8"
+  );
+  const { initializeRegistry, compileRegistry } = await import("./compiler-QKB2ZYNK-CYEN6G5G.js");
+  await initializeRegistry();
+  const { syncRegistrySources } = await import("./sync-XZGFZXZF-6AWT77CE.js");
+  const syncResults = await syncRegistrySources({ showProgress: true });
+  for (const result of syncResults) {
+    if (result.status === "failed") {
+      console.warn(
+        `Warning: Failed to sync ${result.source.id}: ${result.error}`
+      );
+    }
+  }
+  await compileRegistry();
+}
+async function downloadRemotePlugins(version, targetDir) {
+  const releaseUrl = version === "latest" ? "https://github.com/memorysaver/looplia-core/releases/latest/download/plugins.tar.gz" : `https://github.com/memorysaver/looplia-core/releases/download/${version}/plugins.tar.gz`;
+  console.log(`Downloading looplia plugins from ${releaseUrl}...`);
+  const tempDir = join2(tmpdir(), `looplia-download-${Date.now()}`);
+  await mkdir2(tempDir, { recursive: true });
+  try {
+    const response = await fetch(releaseUrl);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download plugins: ${response.status} ${response.statusText}`
+      );
+    }
+    const tarPath = join2(tempDir, "plugins.tar.gz");
+    await writeFile(tarPath, Buffer.from(await response.arrayBuffer()));
+    const checksumUrl = `${releaseUrl}.sha256`;
+    const checksumResponse = await fetch(checksumUrl);
+    if (checksumResponse.ok) {
+      const checksumText = await checksumResponse.text();
+      const checksumParts = checksumText.split(" ");
+      const expectedChecksum = checksumParts[0]?.trim();
+      if (!expectedChecksum) {
+        throw new Error("Invalid checksum file format");
+      }
+      const actualChecksum = await computeSha256(tarPath);
+      if (actualChecksum !== expectedChecksum) {
+        throw new Error(
+          `Checksum verification failed. Expected: ${expectedChecksum}, Got: ${actualChecksum}`
+        );
+      }
+      console.log("\u2713 Checksum verified");
+    } else {
+      console.log(
+        "\u26A0 Checksum file not available (older release), skipping verification"
+      );
+    }
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
+    try {
+      await execAsync2("tar -xzf plugins.tar.gz", { cwd: tempDir });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to extract plugins tarball. Ensure 'tar' is available. Error: ${errorMessage}`
+      );
+    }
+    await rm(tarPath);
+    await validateExtractedPaths(tempDir);
+    await copyPlugins(targetDir, tempDir);
+    console.log(`Plugins downloaded and extracted to ${targetDir}`);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function isLoopliaInitialized() {
+  const pluginPath = getLoopliaPluginPath();
+  const pluginsDir = join2(pluginPath, "plugins");
+  try {
+    const entries = await readdir2(pluginsDir, { withFileTypes: true });
+    return entries.some((e) => e.isDirectory() && !e.name.startsWith("."));
+  } catch {
+    return false;
+  }
+}
+function getDevPluginPaths(projectRoot) {
+  return [
+    { type: "local", path: join2(projectRoot, "plugins", "looplia-core") },
+    { type: "local", path: join2(projectRoot, "plugins", "looplia-writer") }
+  ];
+}
+async function getProdPluginPaths() {
+  const loopliaPath = getLoopliaPluginPath();
+  const pluginsDir = join2(loopliaPath, "plugins");
+  const results = [];
+  try {
+    const entries = await readdir2(pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        results.push({ type: "local", path: join2(pluginsDir, entry.name) });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+async function getPluginPaths() {
+  if (process.env.LOOPLIA_HOME) {
+    return await getProdPluginPaths();
+  }
+  if (process.env.LOOPLIA_DEV === "true") {
+    const devRoot = process.env.LOOPLIA_DEV_ROOT ?? process.cwd();
+    return getDevPluginPaths(devRoot);
+  }
+  return await getProdPluginPaths();
+}
+
+export {
+  CORE_SKILLS,
+  getSelectivePluginPaths,
+  isCoreSkill,
+  getLoopliaPluginPath,
+  copyPlugins,
+  downloadRemotePlugins,
+  isLoopliaInitialized,
+  getPluginPaths
+};

package/dist/{chunk-XTUQVJYH.js → chunk-MTYPUSCH.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
 import {
   pathExists
-} from "./chunk-VRBGWKZ6.js";
+} from "./chunk-326UJHZM.js";
 import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-QHAUYGWN.js
+// ../../packages/provider/dist/chunk-3DYS5U5N.js
 init_esm_shims();
 import { exec } from "child_process";
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
@@ -354,13 +354,25 @@ async function getGitRemoteUrl(repoPath) {
     return;
   }
 }
+async function getSkillSourceUrl(skillPath) {
+  const sourcePath = join(skillPath, "source.json");
+  try {
+    if (await pathExists(sourcePath)) {
+      const content = await readFile(sourcePath, "utf-8");
+      const sourceData = JSON.parse(content);
+      return sourceData.gitUrl;
+    }
+  } 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;
+  const pluginGitUrl = sourceType === "thirdparty" ? await getGitRemoteUrl(pluginPath) : void 0;
   try {
     const skillEntries = await readdir(skillsPath, { withFileTypes: true });
     for (const skillEntry of skillEntries) {
@@ -370,6 +382,8 @@ async function scanPluginDirectory(pluginPath, pluginName, sourceType) {
       const skillPath = join(skillsPath, skillEntry.name);
       const metadata = await parseSkillMetadata(skillPath);
       if (metadata) {
+        const skillGitUrl = await getSkillSourceUrl(skillPath);
+        const gitUrl = skillGitUrl ?? pluginGitUrl;
         skills.push({
           name: metadata.name ?? skillEntry.name,
           title: metadata.title ?? formatTitle(skillEntry.name),
@@ -394,35 +408,20 @@ async function scanPluginDirectory(pluginPath, pluginName, sourceType) {
 }
 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(
+      const pluginDirs = entries.filter(
         (e) => e.isDirectory() && !e.name.startsWith(".")
       );
-      for (const pluginDir of thirdPartyDirs) {
+      for (const pluginDir of pluginDirs) {
         const pluginPath = join(pluginsDir, pluginDir.name);
+        const sourceType = pluginDir.name.startsWith("looplia-") ? "builtin" : "thirdparty";
         const pluginSkills = await scanPluginDirectory(
           pluginPath,
           pluginDir.name,
-          "thirdparty"
+          sourceType
         );
         skills.push(...pluginSkills);
       }