lovecode-ai 0.1.0

package/dist/chunk-IVAMLKMS.js

@@ -0,0 +1,194 @@
+// src/browser/playwright.ts
+import * as fs from "fs";
+import * as path from "path";
+import { createRequire } from "module";
+var _require = createRequire(import.meta.url);
+var defaultConfig = {
+  headless: true,
+  viewport: { width: 1280, height: 800 },
+  timeout: 3e4,
+  screenshotDir: ".lovecode/screenshots"
+};
+var currentBrowser = null;
+var currentPage = null;
+var config = { ...defaultConfig };
+function playwrightAvailable() {
+  try {
+    _require.resolve("playwright");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPlaywrightAvailable() {
+  return playwrightAvailable();
+}
+async function launchBrowser(cfg) {
+  if (!isPlaywrightAvailable()) {
+    throw new Error("Playwright not installed. Run: npm install playwright && npx playwright install chromium");
+  }
+  config = { ...defaultConfig, ...cfg };
+  if (currentBrowser) await closeBrowser();
+  const { chromium } = await import("playwright");
+  const headless = config.headless;
+  currentBrowser = await chromium.launch({ headless });
+  currentPage = await currentBrowser.newPage();
+  await currentPage.setViewportSize(config.viewport);
+}
+async function closeBrowser() {
+  if (currentBrowser) {
+    await currentBrowser.close().catch(() => {
+    });
+    currentBrowser = null;
+    currentPage = null;
+  }
+}
+function isBrowserRunning() {
+  return currentBrowser !== null && currentPage !== null;
+}
+async function goto(url, timeout) {
+  ensurePage();
+  await currentPage.goto(url, { waitUntil: "networkidle", timeout: timeout || config.timeout });
+  return `Navigated to ${url}`;
+}
+async function click(selector) {
+  ensurePage();
+  await currentPage.waitForSelector(selector, { timeout: config.timeout });
+  await currentPage.click(selector);
+  return `Clicked: ${selector}`;
+}
+async function type(selector, text) {
+  ensurePage();
+  await currentPage.waitForSelector(selector, { timeout: config.timeout });
+  await currentPage.fill(selector, text);
+  return `Typed "${text}" into ${selector}`;
+}
+async function select(selector, value) {
+  ensurePage();
+  await currentPage.waitForSelector(selector, { timeout: config.timeout });
+  await currentPage.selectOption(selector, value);
+  return `Selected "${value}" in ${selector}`;
+}
+async function screenshot(name) {
+  ensurePage();
+  const screenshotDir = config.screenshotDir;
+  if (!fs.existsSync(screenshotDir)) {
+    fs.mkdirSync(screenshotDir, { recursive: true });
+  }
+  const timestamp = Date.now();
+  const fileName = name ? `${name}-${timestamp}.png` : `screenshot-${timestamp}.png`;
+  const filePath = path.join(screenshotDir, fileName);
+  await currentPage.screenshot({ path: filePath, fullPage: true });
+  return { path: filePath, width: config.viewport.width, height: config.viewport.height, timestamp };
+}
+async function inspect(selector) {
+  ensurePage();
+  await currentPage.waitForSelector(selector, { timeout: config.timeout });
+  const script = `
+    (sel) => {
+      const el = document.querySelector(sel);
+      if (!el) return null;
+      function describe(node) {
+        return {
+          tag: node.tagName.toLowerCase(),
+          text: (node.textContent || '').slice(0, 200),
+          attributes: Object.fromEntries(Array.from(node.attributes).map(a => [a.name, a.value])),
+          visible: node.offsetParent !== null,
+          children: Array.from(node.children).map(c => describe(c)),
+        };
+      }
+      return describe(el);
+    }
+  `;
+  const result = await currentPage.evaluate(new Function("sel", `return (${script})(sel);`), selector);
+  return result || null;
+}
+async function getHTML(selector) {
+  ensurePage();
+  if (selector) {
+    const script = `document.querySelector("${selector}") ? document.querySelector("${selector}").outerHTML : 'Element not found'`;
+    return await currentPage.evaluate(script);
+  }
+  return await currentPage.evaluate("document.documentElement.outerHTML");
+}
+async function evaluate(script) {
+  ensurePage();
+  return await currentPage.evaluate(script);
+}
+async function waitFor(ms) {
+  ensurePage();
+  await currentPage.waitForTimeout(ms);
+}
+async function runActions(actions) {
+  const results = [];
+  for (const action of actions) {
+    switch (action.type) {
+      case "goto":
+        results.push(await goto(action.url));
+        break;
+      case "click":
+        results.push(await click(action.selector));
+        break;
+      case "type":
+        results.push(await type(action.selector, action.value));
+        break;
+      case "select":
+        results.push(await select(action.selector, action.value));
+        break;
+      case "screenshot":
+        results.push(`Screenshot saved: ${(await screenshot(action.value)).path}`);
+        break;
+      case "inspect":
+        results.push(JSON.stringify(await inspect(action.selector), null, 2));
+        break;
+      case "wait":
+        await waitFor(action.waitFor || 1e3);
+        results.push(`Waited ${action.waitFor || 1e3}ms`);
+        break;
+      case "evaluate":
+        results.push(String(await evaluate(action.script)));
+        break;
+    }
+  }
+  return results;
+}
+function formatScreenshotResult(result) {
+  return `Screenshot: ${result.path} (${result.width}x${result.height})`;
+}
+function formatDOMElement(el, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const attrs = Object.entries(el.attributes).map(([k, v]) => `${k}="${v}"`).join(" ");
+  const visible = el.visible ? "" : " [hidden]";
+  const text = el.text ? ` "${el.text.slice(0, 60)}"` : "";
+  let result = `${pad}<${el.tag}${attrs ? " " + attrs : ""}>${text}${visible}`;
+  for (const child of el.children.slice(0, 10)) {
+    result += "\n" + formatDOMElement(child, indent + 1);
+  }
+  if (el.children.length > 10) {
+    result += `
+${pad}  ... and ${el.children.length - 10} more children`;
+  }
+  return result;
+}
+function ensurePage() {
+  if (!currentPage) throw new Error("Browser not launched. Call lovecode browser start first.");
+}
+
+export {
+  isPlaywrightAvailable,
+  launchBrowser,
+  closeBrowser,
+  isBrowserRunning,
+  goto,
+  click,
+  type,
+  select,
+  screenshot,
+  inspect,
+  getHTML,
+  evaluate,
+  waitFor,
+  runActions,
+  formatScreenshotResult,
+  formatDOMElement
+};

package/dist/chunk-MOZHR2QY.js

@@ -0,0 +1,412 @@
+// src/plugin/registry.ts
+import * as fs from "fs";
+import * as path from "path";
+import { createRequire } from "module";
+
+// src/plugin/types.ts
+import { execSync } from "child_process";
+var PLUGIN_DIR = ".lovecode/plugins";
+var builtinPlugins = [
+  {
+    name: "docker",
+    description: "Docker container management and Dockerfile creation",
+    tags: ["docker", "container", "devops"],
+    create: () => {
+      const tools = [
+        {
+          name: "docker_ps",
+          description: "List running Docker containers",
+          usage: "[all=<true>]",
+          execute(_wd, args) {
+            const flag = args.all === "true" ? "-a" : "";
+            try {
+              const out = execSync(`docker ps ${flag}`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              return { success: true, output: out || "No containers" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "docker_images",
+          description: "List Docker images",
+          usage: "",
+          execute() {
+            try {
+              const out = execSync("docker images", { encoding: "utf-8", timeout: 1e4 }).trim();
+              return { success: true, output: out || "No images" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "docker_compose_up",
+          description: "Start Docker Compose services",
+          usage: "[file=<path>] [detach=<true>]",
+          execute(_wd, args) {
+            try {
+              const file = args.file ? `-f ${args.file}` : "";
+              const detach = args.detach === "true" ? "-d" : "";
+              const out = execSync(`docker compose ${file} up ${detach}`, { encoding: "utf-8", timeout: 6e4 }).trim();
+              return { success: true, output: out || "Started" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        }
+      ];
+      return {
+        name: "docker",
+        version: "1.0.0",
+        manifest: {
+          name: "docker",
+          version: "1.0.0",
+          description: "Docker container management",
+          tags: ["docker", "container", "devops"]
+        },
+        getTools: () => tools
+      };
+    }
+  },
+  {
+    name: "kubernetes",
+    description: "Kubernetes cluster management and pod operations",
+    tags: ["k8s", "kubernetes", "devops"],
+    create: () => {
+      const tools = [
+        {
+          name: "kubectl_get_pods",
+          description: "List Kubernetes pods",
+          usage: "[namespace=<ns>] [all=<true>]",
+          execute(_wd, args) {
+            try {
+              const ns = args.namespace ? `-n ${args.namespace}` : "";
+              const all = args.all === "true" ? "--all-namespaces" : "";
+              const out = execSync(`kubectl get pods ${ns} ${all}`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              return { success: true, output: out || "No pods" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "kubectl_get_services",
+          description: "List Kubernetes services",
+          usage: "[namespace=<ns>]",
+          execute(_wd, args) {
+            try {
+              const flag = args.all === "true" ? "-a" : "";
+              const out = execSync(`docker ps ${flag}`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              return { success: true, output: out || "No containers" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "kubectl_logs",
+          description: "Show pod logs",
+          usage: "pod=<name> [container=<name>] [tail=<lines>]",
+          execute(_wd, args) {
+            try {
+              if (!args.pod) return { success: false, output: "", error: "pod name required" };
+              const container = args.container ? `-c ${args.container}` : "";
+              const tail = args.tail ? `--tail=${args.tail}` : "";
+              const out = execSync(`kubectl logs ${args.pod} ${container} ${tail}`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              return { success: true, output: out || "(empty)" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        }
+      ];
+      return {
+        name: "kubernetes",
+        version: "1.0.0",
+        manifest: {
+          name: "kubernetes",
+          version: "1.0.0",
+          description: "Kubernetes cluster management",
+          tags: ["k8s", "kubernetes", "devops"]
+        },
+        getTools: () => tools
+      };
+    }
+  },
+  {
+    name: "firebase",
+    description: "Firebase deployment and project management",
+    tags: ["firebase", "gcp", "deploy"],
+    create: () => {
+      const tools = [
+        {
+          name: "firebase_deploy",
+          description: "Deploy to Firebase",
+          usage: "[project=<id>] [only=<feature>]",
+          execute(_wd, args) {
+            try {
+              const project = args.project ? `--project ${args.project}` : "";
+              const only = args.only ? `--only ${args.only}` : "";
+              const out = execSync(`firebase deploy ${project} ${only}`, { encoding: "utf-8", timeout: 12e4 }).trim();
+              return { success: true, output: out || "Deployed" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "firebase_emulators",
+          description: "Start Firebase emulators",
+          usage: "[project=<id>]",
+          execute(_wd, args) {
+            try {
+              const project = args.project ? `--project ${args.project}` : "";
+              const out = execSync(`firebase emulators:start ${project}`, { encoding: "utf-8", timeout: 3e4 }).trim();
+              return { success: true, output: out || "Emulators started" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        }
+      ];
+      return {
+        name: "firebase",
+        version: "1.0.0",
+        manifest: {
+          name: "firebase",
+          version: "1.0.0",
+          description: "Firebase deployment and management",
+          tags: ["firebase", "gcp", "deploy"]
+        },
+        getTools: () => tools
+      };
+    }
+  },
+  {
+    name: "prisma",
+    description: "Prisma ORM tools \u2014 schema management, migrations, studio",
+    tags: ["prisma", "database", "orm"],
+    create: () => {
+      const tools = [
+        {
+          name: "prisma_generate",
+          description: "Generate Prisma client",
+          usage: "[schema=<path>]",
+          execute(_wd, args) {
+            try {
+              const schema = args.schema ? `--schema=${args.schema}` : "";
+              const out = execSync(`npx prisma generate ${schema}`, { encoding: "utf-8", timeout: 3e4 }).trim();
+              return { success: true, output: out || "Generated" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "prisma_migrate",
+          description: "Run Prisma migrations",
+          usage: "name=<migration_name> [schema=<path>]",
+          execute(_wd, args) {
+            try {
+              if (!args.name) return { success: false, output: "", error: "name required" };
+              const schema = args.schema ? `--schema=${args.schema}` : "";
+              const out = execSync(`npx prisma migrate dev --name "${args.name}" ${schema}`, { encoding: "utf-8", timeout: 6e4 }).trim();
+              return { success: true, output: out || "Migration created" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        },
+        {
+          name: "prisma_studio",
+          description: "Open Prisma Studio",
+          usage: "[schema=<path>]",
+          execute() {
+            try {
+              execSync("npx prisma studio", { encoding: "utf-8", timeout: 5e3, stdio: "pipe" });
+              return { success: true, output: "Prisma Studio started" };
+            } catch (e) {
+              return { success: true, output: "Prisma Studio launching..." };
+            }
+          }
+        },
+        {
+          name: "prisma_format",
+          description: "Format Prisma schema",
+          usage: "[schema=<path>]",
+          execute(_wd, args) {
+            try {
+              const schema = args.schema ? `--schema=${args.schema}` : "";
+              const out = execSync(`npx prisma format ${schema}`, { encoding: "utf-8", timeout: 15e3 }).trim();
+              return { success: true, output: out || "Formatted" };
+            } catch (e) {
+              return { success: false, output: "", error: String(e) };
+            }
+          }
+        }
+      ];
+      return {
+        name: "prisma",
+        version: "1.0.0",
+        manifest: {
+          name: "prisma",
+          version: "1.0.0",
+          description: "Prisma ORM tools",
+          tags: ["prisma", "database", "orm"]
+        },
+        getTools: () => tools
+      };
+    }
+  }
+];
+
+// src/plugin/registry.ts
+var _require = createRequire(import.meta.url);
+var loadedPlugins = /* @__PURE__ */ new Map();
+var toolListeners = [];
+function onToolsChanged(cb) {
+  toolListeners.push(cb);
+}
+function notifyToolsChanged() {
+  const allTools = getAllPluginTools();
+  for (const cb of toolListeners) {
+    cb(allTools);
+  }
+}
+function registerPlugin(plugin) {
+  const pkg = {
+    manifest: plugin.manifest,
+    module: plugin,
+    enabled: true,
+    loadedAt: Date.now()
+  };
+  loadedPlugins.set(plugin.name, pkg);
+  notifyToolsChanged();
+  return pkg;
+}
+function unregisterPlugin(name) {
+  const pkg = loadedPlugins.get(name);
+  if (!pkg) return false;
+  pkg.module.onUnload?.();
+  loadedPlugins.delete(name);
+  notifyToolsChanged();
+  return true;
+}
+function getPlugin(name) {
+  return loadedPlugins.get(name);
+}
+function listPlugins() {
+  return Array.from(loadedPlugins.values());
+}
+function enablePlugin(name) {
+  const pkg = loadedPlugins.get(name);
+  if (!pkg) return false;
+  pkg.enabled = true;
+  notifyToolsChanged();
+  return true;
+}
+function disablePlugin(name) {
+  const pkg = loadedPlugins.get(name);
+  if (!pkg) return false;
+  pkg.enabled = false;
+  notifyToolsChanged();
+  return true;
+}
+function getAllPluginTools() {
+  const tools = [];
+  for (const pkg of loadedPlugins.values()) {
+    if (!pkg.enabled) continue;
+    if (pkg.module.getTools) {
+      tools.push(...pkg.module.getTools());
+    }
+  }
+  return tools;
+}
+function loadBuiltinPlugins() {
+  const loaded = [];
+  for (const bp of builtinPlugins) {
+    if (loadedPlugins.has(bp.name)) continue;
+    try {
+      const plugin = bp.create();
+      registerPlugin(plugin);
+      loaded.push(bp.name);
+    } catch (err) {
+      console.error(`Failed to load builtin plugin "${bp.name}":`, err);
+    }
+  }
+  return loaded;
+}
+function loadExternalPlugins(rootDir) {
+  const base = rootDir || process.cwd();
+  const pluginDir = path.join(base, PLUGIN_DIR);
+  if (!fs.existsSync(pluginDir)) return [];
+  const loaded = [];
+  for (const entry of fs.readdirSync(pluginDir)) {
+    const fullPath = path.join(pluginDir, entry);
+    if (!fs.statSync(fullPath).isDirectory()) continue;
+    const manifestPath = path.join(fullPath, "plugin.json");
+    const mainPath = path.join(fullPath, "index.js");
+    if (!fs.existsSync(manifestPath) || !fs.existsSync(mainPath)) continue;
+    try {
+      const manifestRaw = fs.readFileSync(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestRaw);
+      const pluginModule = _require(mainPath);
+      pluginModule.manifest = manifest;
+      registerPlugin(pluginModule);
+      loaded.push(entry);
+    } catch (err) {
+      console.error(`Failed to load plugin "${entry}":`, err);
+    }
+  }
+  return loaded;
+}
+function formatPluginList(plugins) {
+  if (plugins.length === 0) return "No plugins loaded.";
+  const lines = ["Loaded Plugins:"];
+  for (const p of plugins) {
+    const status = p.enabled ? "\u2713" : "\u2717";
+    const tags = p.manifest.tags?.join(", ") || "";
+    lines.push(`  ${status} ${p.manifest.name}@${p.manifest.version}  ${p.manifest.description}${tags ? ` (${tags})` : ""}`);
+  }
+  return lines.join("\n");
+}
+var marketplacePlugins = [
+  { name: "docker", version: "1.0.0", description: "Docker container management", author: "LoveCode", downloads: 1200, rating: 4.5, tags: ["docker", "devops"], installUrl: "builtin" },
+  { name: "kubernetes", version: "1.0.0", description: "Kubernetes cluster management", author: "LoveCode", downloads: 890, rating: 4.3, tags: ["k8s", "devops"], installUrl: "builtin" },
+  { name: "firebase", version: "1.0.0", description: "Firebase deployment and management", author: "LoveCode", downloads: 650, rating: 4.1, tags: ["firebase", "deploy"], installUrl: "builtin" },
+  { name: "prisma", version: "1.0.0", description: "Prisma ORM tools", author: "LoveCode", downloads: 1500, rating: 4.7, tags: ["prisma", "database", "orm"], installUrl: "builtin" },
+  { name: "eslint-fixer", version: "1.0.0", description: "Automated ESLint fix suggestions", author: "Community", downloads: 420, rating: 3.8, tags: ["linting", "code-quality"], installUrl: "npm" },
+  { name: "prettier", version: "1.0.0", description: "Prettier code formatting integration", author: "Community", downloads: 380, rating: 4, tags: ["formatting", "code-style"], installUrl: "npm" }
+];
+function searchMarketplace(query) {
+  const lower = query.toLowerCase();
+  return marketplacePlugins.filter(
+    (p) => p.name.toLowerCase().includes(lower) || p.description.toLowerCase().includes(lower) || p.tags.some((t) => t.toLowerCase().includes(lower))
+  );
+}
+function formatMarketplace(plugins) {
+  if (plugins.length === 0) return "No plugins found.";
+  const lines = ["Plugin Marketplace:"];
+  for (const p of plugins) {
+    lines.push(`  ${p.name.padEnd(20)} v${p.version.padEnd(8)} ${(p.rating + "\u2605").padEnd(6)} ${p.downloads} downloads  ${p.description}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  onToolsChanged,
+  registerPlugin,
+  unregisterPlugin,
+  getPlugin,
+  listPlugins,
+  enablePlugin,
+  disablePlugin,
+  getAllPluginTools,
+  loadBuiltinPlugins,
+  loadExternalPlugins,
+  formatPluginList,
+  marketplacePlugins,
+  searchMarketplace,
+  formatMarketplace
+};

package/dist/git-TBOGPTY4.js

@@ -0,0 +1,70 @@
+import {
+  abbreviateDiff,
+  cleanupMergedBranches,
+  commit,
+  createBranch,
+  deleteBranch,
+  detectConflicts,
+  formatBranches,
+  formatConflictInfo,
+  formatLog,
+  formatResolutionSuggestions,
+  formatStatus,
+  generateCommitMessage,
+  generatePRSummary,
+  getBranches,
+  getConflictFiles,
+  getConflictMarkers,
+  getCurrentBranch,
+  getDiff,
+  getFullDiff,
+  getGitRoot,
+  getLog,
+  getPRDiff,
+  getPRLog,
+  getStagedDiff,
+  getStatus,
+  getUnstagedDiff,
+  hasConflicts,
+  isGitAvailable,
+  isRepo,
+  stageAll,
+  stageFiles,
+  suggestResolutions,
+  switchBranch
+} from "./chunk-G7VQGYJW.js";
+export {
+  abbreviateDiff,
+  cleanupMergedBranches,
+  commit,
+  createBranch,
+  deleteBranch,
+  detectConflicts,
+  formatBranches,
+  formatConflictInfo,
+  formatLog,
+  formatResolutionSuggestions,
+  formatStatus,
+  generateCommitMessage,
+  generatePRSummary,
+  getBranches,
+  getConflictFiles,
+  getConflictMarkers,
+  getCurrentBranch,
+  getDiff,
+  getFullDiff,
+  getGitRoot,
+  getLog,
+  getPRDiff,
+  getPRLog,
+  getStagedDiff,
+  getStatus,
+  getUnstagedDiff,
+  hasConflicts,
+  isGitAvailable,
+  isRepo,
+  stageAll,
+  stageFiles,
+  suggestResolutions,
+  switchBranch
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+
+declare const program: Command;
+
+export { program };