ctxloom-pro 1.0.4

package/dist/chunk-IHXVD5SO.js

@@ -0,0 +1,35 @@
+// src/utils/logger.js
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function getConfiguredLevel() {
+  const raw = (process.env.LOG_LEVEL ?? "info").toLowerCase();
+  return raw in LEVELS ? raw : "info";
+}
+function write(level, msg, extra) {
+  if (LEVELS[level] < LEVELS[getConfiguredLevel()])
+    return;
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    msg
+  };
+  if (extra) {
+    Object.assign(entry, extra);
+  }
+  process.stderr.write(JSON.stringify(entry) + "\n");
+}
+var logger = {
+  debug: (msg, extra) => write("debug", msg, extra),
+  info: (msg, extra) => write("info", msg, extra),
+  warn: (msg, extra) => write("warn", msg, extra),
+  error: (msg, extra) => write("error", msg, extra)
+};
+
+export {
+  logger
+};
+//# sourceMappingURL=chunk-IHXVD5SO.js.map

package/dist/chunk-II2DPYRJ.js

@@ -0,0 +1,352 @@
+// src/setup/clients.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+import { execFileSync } from "child_process";
+var HOME = os.homedir();
+var PLATFORM = process.platform;
+function xdgConfig() {
+  if (PLATFORM === "darwin") return path.join(HOME, "Library", "Application Support");
+  if (PLATFORM === "win32") return process.env.APPDATA ?? path.join(HOME, "AppData", "Roaming");
+  return process.env.XDG_CONFIG_HOME ?? path.join(HOME, ".config");
+}
+var CTXLOOM_SERVER = {
+  command: "npx",
+  args: ["-y", "ctxloom"],
+  env: {}
+};
+var _serverEntry;
+function getServerEntry() {
+  if (_serverEntry) return _serverEntry;
+  _serverEntry = commandExists("ctxloom") ? { command: "ctxloom", args: [], env: {} } : CTXLOOM_SERVER;
+  return _serverEntry;
+}
+var MCP_CLIENTS = [
+  // ─── Claude Desktop ───────────────────────────────────────
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    description: "Anthropic Claude desktop application",
+    configPaths: [
+      path.join(HOME, ".claude", "claude_desktop_config.json"),
+      path.join(xdgConfig(), "Claude", "claude_desktop_config.json")
+    ],
+    cliBinaries: ["claude-desktop"],
+    appBundles: ["com.anthropic.claudedesktop"],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Claude Code (CLI) ───────────────────────────────────
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    description: "Anthropic Claude Code CLI agent",
+    configPaths: [
+      path.join(HOME, ".claude", "mcp.json"),
+      path.join(HOME, ".claude.json")
+    ],
+    cliBinaries: ["claude"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Cursor ─────────────────────────────────────────────
+  {
+    id: "cursor",
+    name: "Cursor",
+    description: "Cursor AI code editor",
+    configPaths: [
+      path.join(xdgConfig(), "Cursor", "User", "globalStorage", "cursor-mcp", "mcp.json"),
+      path.join(HOME, ".cursor", "mcp.json"),
+      path.join(xdgConfig(), "Cursor", "mcp.json")
+    ],
+    cliBinaries: ["cursor"],
+    appBundles: ["com.todesktop.230313mzl4w4u92"],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── VS Code (GitHub Copilot MCP) ───────────────────────
+  {
+    id: "vscode",
+    name: "VS Code",
+    description: "Visual Studio Code with MCP support",
+    configPaths: [
+      path.join(HOME, ".vscode", "mcp.json"),
+      path.join(xdgConfig(), "Code", "User", "globalStorage", "mcp.json"),
+      path.join(xdgConfig(), "Code - Insiders", "User", "globalStorage", "mcp.json")
+    ],
+    cliBinaries: ["code"],
+    appBundles: ["com.microsoft.VSCode", "com.microsoft.VSCodeInsiders"],
+    usesMcpServersFormat: true,
+    serversPath: "servers"
+  },
+  // ─── Windsurf (Codeium) ──────────────────────────────────
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    description: "Windsurf AI code editor by Codeium",
+    configPaths: [
+      path.join(xdgConfig(), "Windsurf", "User", "globalStorage", "windsurf-mcp", "mcp.json"),
+      path.join(HOME, ".windsurf", "mcp.json")
+    ],
+    cliBinaries: ["windsurf"],
+    appBundles: ["com.codeium.windsurf"],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Augment Code ───────────────────────────────────────
+  {
+    id: "augment",
+    name: "Augment Code",
+    description: "Augment Code AI assistant",
+    configPaths: [
+      path.join(xdgConfig(), "Augment", "mcp.json"),
+      path.join(HOME, ".augment", "mcp.json"),
+      path.join(xdgConfig(), "Augment Code", "mcp.json")
+    ],
+    cliBinaries: ["augment"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Kilo Code ──────────────────────────────────────────
+  {
+    id: "kilo-code",
+    name: "Kilo Code",
+    description: "Kilo Code AI coding assistant",
+    configPaths: [
+      path.join(xdgConfig(), "KiloCode", "mcp.json"),
+      path.join(HOME, ".kilocode", "mcp.json")
+    ],
+    cliBinaries: ["kilo-code", "kilocode"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Continue.dev ───────────────────────────────────────
+  {
+    id: "continue",
+    name: "Continue.dev",
+    description: "Continue open-source AI code assistant",
+    configPaths: [
+      path.join(HOME, ".continue", "config.json"),
+      path.join(xdgConfig(), "continue", "config.json")
+    ],
+    cliBinaries: ["continue"],
+    appBundles: [],
+    usesMcpServersFormat: false,
+    serversPath: "experimental.mcpServers",
+    formatConfig: (entry) => ({
+      command: entry.command,
+      args: entry.args,
+      transport: "stdio"
+    })
+  },
+  // ─── Aider ──────────────────────────────────────────────
+  {
+    id: "aider",
+    name: "Aider",
+    description: "Aider AI pair programming CLI",
+    configPaths: [
+      path.join(HOME, ".aider", "mcp.json"),
+      path.join(xdgConfig(), "aider", "mcp.json")
+    ],
+    cliBinaries: ["aider"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Codex CLI (OpenAI) ─────────────────────────────────
+  {
+    id: "codex",
+    name: "Codex CLI",
+    description: "OpenAI Codex CLI agent",
+    configPaths: [
+      path.join(HOME, ".codex", "mcp.json"),
+      path.join(xdgConfig(), "codex", "mcp.json")
+    ],
+    cliBinaries: ["codex"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Kimi ───────────────────────────────────────────────
+  {
+    id: "kimi",
+    name: "Kimi",
+    description: "Moonshot AI Kimi coding assistant",
+    configPaths: [
+      path.join(HOME, ".kimi", "mcp.json"),
+      path.join(xdgConfig(), "kimi", "mcp.json")
+    ],
+    cliBinaries: ["kimi"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Qwen (Alibaba) ─────────────────────────────────────
+  {
+    id: "qwen",
+    name: "Qwen Code",
+    description: "Alibaba Qwen coding assistant",
+    configPaths: [
+      path.join(HOME, ".qwen", "mcp.json"),
+      path.join(xdgConfig(), "qwen", "mcp.json")
+    ],
+    cliBinaries: ["qwen-code", "qwen"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── JetBrains AI ───────────────────────────────────────
+  {
+    id: "jetbrains",
+    name: "JetBrains AI",
+    description: "JetBrains IDE with AI assistant",
+    configPaths: [
+      path.join(xdgConfig(), "JetBrains", "ai-mcp.json")
+    ],
+    cliBinaries: [],
+    appBundles: ["com.jetbrains.intellij"],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  }
+];
+function detectInstalledClients() {
+  const results = [];
+  for (const client of MCP_CLIENTS) {
+    let detected = false;
+    let configPath = "";
+    let configExists = false;
+    let alreadyConfigured = false;
+    for (const cp of client.configPaths) {
+      if (fs.existsSync(cp)) {
+        detected = true;
+        configPath = cp;
+        configExists = true;
+        try {
+          const content = fs.readFileSync(cp, "utf-8");
+          const config = JSON.parse(content);
+          const servers = getNestedValue(config, client.serversPath);
+          if (servers && servers["ctxloom"]) {
+            alreadyConfigured = true;
+          }
+        } catch {
+        }
+        break;
+      }
+    }
+    if (!detected) {
+      for (const bin of client.cliBinaries) {
+        if (commandExists(bin)) {
+          detected = true;
+          configPath = client.configPaths[0];
+          break;
+        }
+      }
+    }
+    if (!detected && PLATFORM === "darwin") {
+      for (const bundle of client.appBundles) {
+        const appLocations = [
+          `/Applications/${bundle.split(".").pop()}.app`,
+          path.join(HOME, "Applications", `${bundle.split(".").pop()}.app`)
+        ];
+        for (const loc of appLocations) {
+          if (fs.existsSync(loc)) {
+            detected = true;
+            configPath = client.configPaths[0];
+            break;
+          }
+        }
+        if (detected) break;
+      }
+    }
+    if (detected) {
+      results.push({
+        client,
+        configPath,
+        configExists,
+        alreadyConfigured
+      });
+    }
+  }
+  return results;
+}
+function getNestedValue(obj, path2) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setNestedValue(obj, path2, value) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!(parts[i] in current) || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function commandExists(cmd) {
+  const isWin = PLATFORM === "win32";
+  const checkCmd = isWin ? "where" : "which";
+  try {
+    const result = execFileSync(checkCmd, [cmd], {
+      encoding: "utf-8",
+      timeout: 500,
+      stdio: "pipe"
+    });
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function addCtxloomToConfig(detected) {
+  const { client, configPath, configExists, alreadyConfigured } = detected;
+  if (alreadyConfigured) {
+    return { success: true, message: `ctxloom is already configured in ${client.name}` };
+  }
+  let config;
+  if (configExists) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      config = JSON.parse(content);
+    } catch {
+      return { success: false, message: `Failed to parse existing config at ${configPath}` };
+    }
+  } else {
+    config = {};
+  }
+  const serverEntry = getServerEntry();
+  const entryValue = client.formatConfig ? client.formatConfig(serverEntry) : { command: serverEntry.command, args: serverEntry.args, ...serverEntry.env && Object.keys(serverEntry.env).length > 0 ? { env: serverEntry.env } : {} };
+  let servers = getNestedValue(config, client.serversPath);
+  if (!servers || typeof servers !== "object") {
+    setNestedValue(config, client.serversPath, {});
+    servers = getNestedValue(config, client.serversPath);
+  }
+  servers["ctxloom"] = entryValue;
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return { success: true, message: `Added ctxloom to ${client.name} (${configPath})` };
+  } catch (err) {
+    return { success: false, message: `Failed to write config at ${configPath}: ${err}` };
+  }
+}
+
+export {
+  detectInstalledClients,
+  addCtxloomToConfig
+};
+//# sourceMappingURL=chunk-II2DPYRJ.js.map

package/dist/chunk-PSLPRDPL.js

@@ -0,0 +1,139 @@
+// src/rules/types.ts
+var RulesConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RulesConfigError";
+  }
+};
+
+// src/rules/loadConfig.ts
+import fs from "fs/promises";
+import path from "path";
+import yaml from "js-yaml";
+import { z } from "zod";
+var RuleSchema = z.object({
+  name: z.string(),
+  type: z.literal("no-import"),
+  from: z.string(),
+  to: z.string(),
+  severity: z.enum(["error", "warn"]).optional()
+});
+var RulesConfigSchema = z.object({
+  version: z.literal(1),
+  rules: z.array(RuleSchema).default([])
+});
+async function loadRulesConfig(rootDir) {
+  const filePath = path.join(rootDir, ".ctxloom", "rules.yml");
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw new RulesConfigError(`Failed to read rules config: ${String(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = yaml.load(raw);
+  } catch (err) {
+    throw new RulesConfigError(`Invalid YAML in .ctxloom/rules.yml: ${String(err)}`);
+  }
+  const result = RulesConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const messages = result.error.errors.map((e) => `  ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new RulesConfigError(`Invalid .ctxloom/rules.yml schema:
+${messages}`);
+  }
+  return result.data;
+}
+
+// src/rules/RulesChecker.ts
+import picomatch from "picomatch";
+var RulesChecker = class {
+  constructor(graph, config) {
+    this.graph = graph;
+    this.config = config;
+  }
+  graph;
+  config;
+  check() {
+    const start = Date.now();
+    const violations = [];
+    const warnings = [];
+    const allFiles = this.graph.allFiles();
+    for (const rule of this.config.rules) {
+      const fromMatcher = picomatch(rule.from, { dot: true });
+      const toMatcher = picomatch(rule.to, { dot: true });
+      const fromFiles = allFiles.filter((f) => fromMatcher(f));
+      const toFiles = new Set(allFiles.filter((f) => toMatcher(f)));
+      if (fromFiles.length === 0 || toFiles.size === 0) {
+        warnings.push(`rule "${rule.name}" matched 0 files on from/to \u2014 check glob`);
+        continue;
+      }
+      const severity = rule.severity ?? "error";
+      for (const fromFile of fromFiles) {
+        for (const importedFile of this.graph.getImports(fromFile)) {
+          if (toFiles.has(importedFile)) {
+            violations.push({
+              rule: rule.name,
+              severity,
+              fromFile,
+              toFile: importedFile,
+              message: `${fromFile} must not import ${importedFile}  [${rule.name}]`
+            });
+          }
+        }
+      }
+    }
+    return {
+      violations,
+      warnings,
+      rulesChecked: this.config.rules.length,
+      filesChecked: allFiles.length,
+      durationMs: Date.now() - start
+    };
+  }
+};
+
+// src/rules/reporter.ts
+function formatText(result, limit = 50) {
+  const lines = [];
+  if (result.warnings.length > 0) {
+    for (const w of result.warnings) {
+      lines.push(`  \u26A0  ${w}`);
+    }
+    lines.push("");
+  }
+  const toShow = limit === 0 ? result.violations : result.violations.slice(0, limit);
+  const hidden = result.violations.length - toShow.length;
+  for (const v of toShow) {
+    const tag = v.severity === "warn" ? "WARN" : "ERROR";
+    lines.push(`  [${tag}] ${v.message}`);
+  }
+  if (hidden > 0) {
+    lines.push(`
+  ... and ${hidden} more. Run with --json for full output.`);
+  }
+  if (result.violations.length === 0) {
+    lines.push(
+      `\u2713 ${result.rulesChecked} rules checked, 0 violations. (${result.filesChecked} files, ${result.durationMs}ms)`
+    );
+  } else {
+    lines.push(
+      `
+${result.violations.length} violation(s) found. (${result.filesChecked} files, ${result.rulesChecked} rules, ${result.durationMs}ms)`
+    );
+  }
+  return lines.join("\n");
+}
+function formatJson(result) {
+  return JSON.stringify({ schemaVersion: 1, ...result }, null, 2);
+}
+
+export {
+  RulesConfigError,
+  loadRulesConfig,
+  RulesChecker,
+  formatText,
+  formatJson
+};
+//# sourceMappingURL=chunk-PSLPRDPL.js.map