@looplia/looplia-cli 0.7.0 → 0.7.1

package/dist/chunk-NUQVUYOZ.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env bun
+import {
+  FRONTMATTER_REGEX,
+  PROTOCOL_REGEX,
+  TRAILING_SLASH_REGEX,
+  createProgress,
+  loadSources
+} from "./chunk-DN3RSIIJ.js";
+import {
+  isValidGitUrl,
+  isValidPathSegment,
+  pathExists
+} from "./chunk-VRBGWKZ6.js";
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/chunk-CB45NMLW.js
+init_esm_shims();
+import { exec } from "child_process";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { basename, join } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var MAX_SKILL_SEARCH_DEPTH = 5;
+function getLoopliaHome() {
+  return process.env.LOOPLIA_HOME ?? join(homedir(), ".looplia");
+}
+function getPluginsDir() {
+  return join(getLoopliaHome(), "plugins");
+}
+async function findSkillMdPath(repoPath) {
+  async function searchDir(dirPath, depth, maxDepth) {
+    if (depth > maxDepth) {
+      return null;
+    }
+    const entries = await readdir(dirPath, { withFileTypes: true }).catch(
+      () => []
+    );
+    const hasSkillMd = entries.some((e) => e.isFile() && e.name === "SKILL.md");
+    if (hasSkillMd) {
+      return dirPath;
+    }
+    const subdirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
+    );
+    for (const subdir of subdirs) {
+      const found = await searchDir(
+        join(dirPath, subdir.name),
+        depth + 1,
+        maxDepth
+      );
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  return await searchDir(repoPath, 0, MAX_SKILL_SEARCH_DEPTH);
+}
+async function extractSkillName(skillMdDir) {
+  try {
+    const content = await readFile(join(skillMdDir, "SKILL.md"), "utf-8");
+    const match = content.match(FRONTMATTER_REGEX);
+    if (match?.[1]) {
+      const lines = match[1].split("\n");
+      for (const line of lines) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex > 0) {
+          const key = line.slice(0, colonIndex).trim();
+          const value = line.slice(colonIndex + 1).trim();
+          if (key === "name" && value) {
+            return value;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return basename(skillMdDir);
+}
+async function isValidPluginStructure(repoPath) {
+  const claudePluginDir = join(repoPath, ".claude-plugin");
+  const pluginJsonPath = join(claudePluginDir, "plugin.json");
+  const marketplaceJsonPath = join(claudePluginDir, "marketplace.json");
+  return await pathExists(pluginJsonPath) || await pathExists(marketplaceJsonPath);
+}
+async function hasMarketplaceJson(repoPath) {
+  return await pathExists(join(repoPath, ".claude-plugin", "marketplace.json"));
+}
+async function createPluginStructure(opts) {
+  const { pluginDir, plugin, marketplace } = opts;
+  await mkdir(join(pluginDir, ".claude-plugin"), { recursive: true });
+  await mkdir(join(pluginDir, "skills"), { recursive: true });
+  const pluginJson = {
+    name: plugin.name,
+    description: plugin.description,
+    source: { marketplace: marketplace.name, url: marketplace.url }
+  };
+  await writeFile(
+    join(pluginDir, ".claude-plugin", "plugin.json"),
+    JSON.stringify(pluginJson, null, 2)
+  );
+}
+async function copyPluginSkills(plugin, tempDir, pluginDir) {
+  if (plugin.skills?.length) {
+    for (const skillPath of plugin.skills) {
+      const skillName = basename(skillPath);
+      const srcPath = join(tempDir, skillPath);
+      const destPath = join(pluginDir, "skills", skillName);
+      if (await pathExists(srcPath)) {
+        await cp(srcPath, destPath, { recursive: true });
+      }
+    }
+  } else {
+    const srcPath = join(tempDir, plugin.source);
+    const destPath = join(pluginDir, "skills", plugin.name);
+    if (await pathExists(srcPath)) {
+      await cp(srcPath, destPath, { recursive: true });
+    }
+  }
+}
+async function wrapSkillAsPlugin(skillPath, skillName, targetPath, originalUrl) {
+  if (!isValidPathSegment(skillName)) {
+    throw new Error(
+      `Invalid skill name: "${skillName}" - contains path traversal characters`
+    );
+  }
+  await mkdir(join(targetPath, ".claude-plugin"), { recursive: true });
+  const skillTargetDir = join(targetPath, "skills", skillName);
+  await mkdir(skillTargetDir, { recursive: true });
+  await cp(skillPath, skillTargetDir, { recursive: true });
+  const pluginJson = {
+    name: skillName,
+    version: "1.0.0",
+    description: `Auto-wrapped skill from ${originalUrl}`,
+    source: {
+      type: "auto-wrapped",
+      originalUrl,
+      wrappedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  await writeFile(
+    join(targetPath, ".claude-plugin", "plugin.json"),
+    JSON.stringify(pluginJson, null, 2)
+  );
+}
+async function installMarketplaceSource(tempDir, source, pluginsDir) {
+  const marketplacePath = join(tempDir, ".claude-plugin", "marketplace.json");
+  if (!await pathExists(marketplacePath)) {
+    return [];
+  }
+  const marketplaceContent = await readFile(marketplacePath, "utf-8");
+  const manifest = JSON.parse(marketplaceContent);
+  const marketplace = { name: manifest.name, url: source.url };
+  const results = [];
+  for (const plugin of manifest.plugins) {
+    const pluginDir = join(pluginsDir, plugin.name);
+    try {
+      await createPluginStructure({ pluginDir, plugin, marketplace });
+      await copyPluginSkills(plugin, tempDir, pluginDir);
+      results.push({
+        skill: plugin.name,
+        status: "installed",
+        path: pluginDir
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({ skill: plugin.name, status: "failed", error: message });
+    }
+  }
+  return results;
+}
+async function installPluginSource(tempDir, source, pluginsDir) {
+  const repoName = source.url.replace(PROTOCOL_REGEX, "").replace("github.com/", "").replace(TRAILING_SLASH_REGEX, "").replace(/\//g, "-");
+  const targetPath = join(pluginsDir, repoName);
+  if (await pathExists(targetPath)) {
+    return {
+      skill: repoName,
+      status: "already_installed",
+      path: targetPath
+    };
+  }
+  await cp(tempDir, targetPath, { recursive: true });
+  return {
+    skill: repoName,
+    status: "installed",
+    path: targetPath
+  };
+}
+async function installStandaloneSkill(_tempDir, source, pluginsDir, skillMdDir) {
+  const extractedName = await extractSkillName(skillMdDir);
+  const targetPath = join(pluginsDir, extractedName);
+  if (await pathExists(targetPath)) {
+    return {
+      skill: extractedName,
+      status: "already_installed",
+      path: targetPath
+    };
+  }
+  await wrapSkillAsPlugin(skillMdDir, extractedName, targetPath, source.url);
+  return {
+    skill: extractedName,
+    status: "installed",
+    path: targetPath
+  };
+}
+async function installSkillFromPath(tempDir, source, pluginsDir, skillPath) {
+  const skillSourcePath = join(tempDir, skillPath);
+  if (!await pathExists(skillSourcePath)) {
+    return {
+      skill: skillPath,
+      status: "failed",
+      error: `Path not found in marketplace: ${skillPath}`
+    };
+  }
+  const skillMdDir = await findSkillMdPath(skillSourcePath);
+  if (!skillMdDir) {
+    return {
+      skill: skillPath,
+      status: "failed",
+      error: `No SKILL.md found at ${skillPath}`
+    };
+  }
+  const extractedName = await extractSkillName(skillMdDir);
+  const targetPath = join(pluginsDir, extractedName);
+  if (await pathExists(targetPath)) {
+    return {
+      skill: extractedName,
+      status: "already_installed",
+      path: targetPath
+    };
+  }
+  await wrapSkillAsPlugin(
+    skillMdDir,
+    extractedName,
+    targetPath,
+    `${source.url}/${skillPath}`
+  );
+  return {
+    skill: extractedName,
+    status: "installed",
+    path: targetPath
+  };
+}
+async function detectAndInstallSource(tempDir, source, pluginsDir, progress) {
+  if (await hasMarketplaceJson(tempDir)) {
+    progress?.start("Installing marketplace plugins");
+    const results = await installMarketplaceSource(tempDir, source, pluginsDir);
+    const installed = results.filter((r) => r.status === "installed").length;
+    progress?.succeed(`Installed ${installed} plugins from ${source.id}`);
+    return { source, status: "synced", plugins: results };
+  }
+  if (await isValidPluginStructure(tempDir)) {
+    progress?.start("Installing plugin");
+    const result2 = await installPluginSource(tempDir, source, pluginsDir);
+    progress?.succeed(`Installed ${result2.skill}`);
+    return {
+      source,
+      status: result2.status === "installed" ? "synced" : "skipped",
+      plugins: [result2]
+    };
+  }
+  progress?.start("Analyzing structure");
+  const skillMdDir = await findSkillMdPath(tempDir);
+  if (!skillMdDir) {
+    progress?.fail("No plugin structure or SKILL.md found");
+    return {
+      source,
+      status: "failed",
+      plugins: [],
+      error: "No .claude-plugin/plugin.json or SKILL.md found in repository"
+    };
+  }
+  progress?.start("Auto-wrapping as plugin");
+  const result = await installStandaloneSkill(
+    tempDir,
+    source,
+    pluginsDir,
+    skillMdDir
+  );
+  progress?.succeed(`Installed ${result.skill} (auto-wrapped)`);
+  return {
+    source,
+    status: result.status === "installed" ? "synced" : "skipped",
+    plugins: [result]
+  };
+}
+async function syncSource(source, options) {
+  const {
+    showProgress = false,
+    force: _force = false,
+    skillPath
+  } = options ?? {};
+  const progress = showProgress ? createProgress() : null;
+  const pluginsDir = getPluginsDir();
+  await mkdir(pluginsDir, { recursive: true });
+  if (!isValidGitUrl(source.url)) {
+    return {
+      source,
+      status: "failed",
+      plugins: [],
+      error: `Invalid or untrusted git URL: ${source.url}`
+    };
+  }
+  const safeSourceId = source.id.replace(/[^a-zA-Z0-9-]/g, "-");
+  const tempDir = join(tmpdir(), `looplia-sync-${safeSourceId}-${Date.now()}`);
+  try {
+    progress?.start(`Cloning ${source.id}`);
+    await execAsync(`git clone --depth 1 "${source.url}" "${tempDir}"`);
+    progress?.succeed(`Cloned ${source.id}`);
+    if (skillPath) {
+      progress?.start(`Installing skill: ${skillPath}`);
+      const result = await installSkillFromPath(
+        tempDir,
+        source,
+        pluginsDir,
+        skillPath
+      );
+      progress?.succeed(`Installed ${result.skill}`);
+      return {
+        source,
+        status: result.status === "installed" ? "synced" : "skipped",
+        plugins: [result]
+      };
+    }
+    return await detectAndInstallSource(tempDir, source, pluginsDir, progress);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    progress?.fail(`Failed to sync ${source.id}`);
+    return {
+      source,
+      status: "failed",
+      plugins: [],
+      error: message
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function syncRegistrySources(options) {
+  const { showProgress = false, sourcesToSync, force = false } = options ?? {};
+  const progress = showProgress ? createProgress() : null;
+  const allSources = await loadSources();
+  const sources = allSources.filter((s) => {
+    if (!s.enabled) {
+      return false;
+    }
+    if (sourcesToSync && !sourcesToSync.includes(s.id)) {
+      return false;
+    }
+    return true;
+  });
+  if (sources.length === 0) {
+    progress?.succeed("No sources to sync");
+    return [];
+  }
+  progress?.start(`Syncing ${sources.length} sources`);
+  const results = await Promise.all(
+    sources.map((source) => syncSource(source, { showProgress: false, force }))
+  );
+  const successCount = results.filter((r) => r.status === "synced").length;
+  const failedCount = results.filter((r) => r.status === "failed").length;
+  if (failedCount > 0) {
+    progress?.warn(
+      `Synced ${successCount}/${sources.length} sources (${failedCount} failed)`
+    );
+  } else {
+    progress?.succeed(`Synced ${successCount} sources`);
+  }
+  return results;
+}
+
+export {
+  syncSource,
+  syncRegistrySources
+};

package/dist/{chunk-FCL2HRTX.js → chunk-VRBGWKZ6.js}

@@ -1,27 +1,19 @@
-#!/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 });
-};
+#!/usr/bin/env bun
+import {
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
 
-// ../../node_modules/tsup/assets/esm_shims.js
+// ../../packages/provider/dist/chunk-MM63NAER.js
+init_esm_shims();
 import path from "path";
 import { fileURLToPath } from "url";
+import { mkdir, stat } from "fs/promises";
 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) {
+async function pathExists(path2) {
   try {
-    await stat(path22);
+    await stat(path2);
     return true;
   } catch {
     return false;
@@ -55,9 +47,7 @@ function isValidPathSegment(pathSegment) {
 }
 
 export {
-  __export,
   __dirname,
-  __dirname2,
   pathExists,
   isValidGitUrl,
   isValidPathSegment

package/dist/chunk-Y55L47HC.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "../../node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  __dirname,
+  init_esm_shims
+};

package/dist/claude-agent-sdk-BKJ5OHH6.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+import "./chunk-APZNHRV3.js";
+import {
+  DEFAULT_SETTINGS,
+  PRESETS,
+  SUMMARIZE_SYSTEM_PROMPT,
+  WRITING_KIT_OUTPUT_SCHEMA,
+  applyPreset,
+  buildSummarizePrompt,
+  clearClaudeCodePathCache,
+  createClaudeAgentExecutor,
+  createQueryLogger,
+  ensureWorkspace,
+  executeAgenticQueryStreaming,
+  executeInteractiveQueryStreaming,
+  expandPath,
+  extractContentIdFromPrompt,
+  findClaudeCodePath,
+  getConfigPath,
+  getLoopliaHome,
+  getPluginPath,
+  getSettingsDisplayInfo,
+  getWorkspacePath,
+  initializeCommandEnvironment,
+  injectLoopliaSettingsEnv,
+  isClaudeCodeInstalled,
+  maskAuthToken,
+  readLoopliaSettings,
+  readUserProfile,
+  removeLoopliaSettings,
+  validateConfig,
+  writeLoopliaSettings,
+  writeUserProfile
+} from "./chunk-HSZZVXV5.js";
+import "./chunk-VRBGWKZ6.js";
+import "./chunk-Y55L47HC.js";
+export {
+  DEFAULT_SETTINGS,
+  PRESETS,
+  SUMMARIZE_SYSTEM_PROMPT,
+  WRITING_KIT_OUTPUT_SCHEMA,
+  applyPreset,
+  buildSummarizePrompt,
+  clearClaudeCodePathCache,
+  createClaudeAgentExecutor,
+  createQueryLogger,
+  ensureWorkspace,
+  executeAgenticQueryStreaming,
+  executeInteractiveQueryStreaming,
+  expandPath,
+  extractContentIdFromPrompt,
+  findClaudeCodePath,
+  getConfigPath,
+  getLoopliaHome,
+  getPluginPath,
+  getSettingsDisplayInfo,
+  getWorkspacePath,
+  initializeCommandEnvironment,
+  injectLoopliaSettingsEnv,
+  isClaudeCodeInstalled,
+  maskAuthToken,
+  readLoopliaSettings,
+  readUserProfile,
+  removeLoopliaSettings,
+  validateConfig,
+  writeLoopliaSettings,
+  writeUserProfile
+};