@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-TAIJOFOE.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/work-log-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var WORK_LOG_DIR = ".paradigm/work-log";
-function generateWorkLogId(agent) {
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().slice(0, 10);
-  const sanitized = agent.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 20);
-  const counter = String(Math.floor(Math.random() * 999) + 1).padStart(3, "0");
-  return `WL-${sanitized}-${date}-${counter}`;
-}
-function getDateDir(rootDir, date) {
-  return path.join(rootDir, WORK_LOG_DIR, date);
-}
-function recordWorkLog(rootDir, entry) {
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().slice(0, 10);
-  const id = generateWorkLogId(entry.agent);
-  const full = {
-    id,
-    timestamp: now.toISOString(),
-    ...entry
-  };
-  const dir = getDateDir(rootDir, date);
-  fs.mkdirSync(dir, { recursive: true });
-  const filePath = path.join(dir, `${id}.yaml`);
-  fs.writeFileSync(filePath, yaml.dump(full, { lineWidth: 120, noRefs: true }), "utf8");
-  return full;
-}
-function loadWorkLogEntries(rootDir, filter) {
-  const baseDir = path.join(rootDir, WORK_LOG_DIR);
-  if (!fs.existsSync(baseDir)) return [];
-  const entries = [];
-  const dateDirs = fs.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(d.name)).map((d) => d.name).sort().reverse();
-  for (const dateDir of dateDirs) {
-    if (filter?.dateFrom && dateDir < filter.dateFrom) continue;
-    if (filter?.dateTo && dateDir > filter.dateTo) continue;
-    const dirPath = path.join(baseDir, dateDir);
-    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
-        const entry = yaml.load(content);
-        if (entry && entry.id) {
-          entries.push(entry);
-        }
-      } catch {
-      }
-    }
-  }
-  let filtered = entries;
-  if (filter?.agent) {
-    filtered = filtered.filter((e) => e.agent === filter.agent);
-  }
-  if (filter?.outcome) {
-    filtered = filtered.filter((e) => e.outcome === filter.outcome);
-  }
-  if (filter?.task_ref) {
-    filtered = filtered.filter((e) => e.task_ref === filter.task_ref);
-  }
-  if (filter?.symbol) {
-    filtered = filtered.filter((e) => e.symbols_touched?.includes(filter.symbol));
-  }
-  filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-  if (filter?.limit) {
-    filtered = filtered.slice(0, filter.limit);
-  }
-  return filtered;
-}
-function loadWorkLogEntry(rootDir, id) {
-  const baseDir = path.join(rootDir, WORK_LOG_DIR);
-  if (!fs.existsSync(baseDir)) return null;
-  const match = id.match(/WL-[^-]+-(\d{4}-\d{2}-\d{2})-/);
-  if (match) {
-    const filePath = path.join(baseDir, match[1], `${id}.yaml`);
-    if (fs.existsSync(filePath)) {
-      const content = fs.readFileSync(filePath, "utf8");
-      return yaml.load(content);
-    }
-  }
-  const dateDirs = fs.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const dir of dateDirs) {
-    const filePath = path.join(baseDir, dir.name, `${id}.yaml`);
-    if (fs.existsSync(filePath)) {
-      const content = fs.readFileSync(filePath, "utf8");
-      return yaml.load(content);
-    }
-  }
-  return null;
-}
-function getWorkLogSummary(rootDir, days = 7) {
-  const cutoff = /* @__PURE__ */ new Date();
-  cutoff.setDate(cutoff.getDate() - days);
-  const dateFrom = cutoff.toISOString().slice(0, 10);
-  const entries = loadWorkLogEntries(rootDir, { dateFrom });
-  const byOutcome = { pass: 0, fail: 0, partial: 0, blocked: 0 };
-  const byAgent = {};
-  for (const e of entries) {
-    byOutcome[e.outcome] = (byOutcome[e.outcome] || 0) + 1;
-    byAgent[e.agent] = (byAgent[e.agent] || 0) + 1;
-  }
-  return {
-    total: entries.length,
-    byOutcome,
-    byAgent,
-    recentEntries: entries.slice(0, 10).map((e) => ({
-      id: e.id,
-      agent: e.agent,
-      summary: e.summary,
-      outcome: e.outcome,
-      timestamp: e.timestamp
-    }))
-  };
-}
-
-export {
-  recordWorkLog,
-  loadWorkLogEntries,
-  loadWorkLogEntry,
-  getWorkLogSummary
-};

package/dist/chunk-TXESEO7Y.js

@@ -1,245 +0,0 @@
-#!/usr/bin/env node
-
-// src/core/provider-registry.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var providers = /* @__PURE__ */ new Map();
-var defaultProviderName = null;
-var initialized = false;
-var PROVIDER_PRIORITY = ["claude", "claude-code-teams", "claude-code", "cursor-cli", "claude-cli", "manual"];
-var VALID_PROVIDERS = ["auto", ...PROVIDER_PRIORITY];
-var configuredProvider = null;
-function registerProvider(provider) {
-  providers.set(provider.name, provider);
-}
-function getProvider(name) {
-  if (name && providers.has(name)) {
-    return providers.get(name) || null;
-  }
-  if (defaultProviderName && providers.has(defaultProviderName)) {
-    return providers.get(defaultProviderName) || null;
-  }
-  return null;
-}
-function getConfiguredProvider(rootDir) {
-  const envProvider = process.env.PARADIGM_AGENT_PROVIDER;
-  if (envProvider && VALID_PROVIDERS.includes(envProvider)) {
-    return envProvider;
-  }
-  if (configuredProvider !== null) {
-    return configuredProvider;
-  }
-  const dir = rootDir || process.cwd();
-  const configPath = path.join(dir, ".paradigm", "config.yaml");
-  if (fs.existsSync(configPath)) {
-    try {
-      const content = fs.readFileSync(configPath, "utf-8");
-      const config = yaml.load(content);
-      const provider = config["agent-provider"];
-      if (provider && VALID_PROVIDERS.includes(provider)) {
-        configuredProvider = provider;
-        return provider;
-      }
-    } catch {
-    }
-  }
-  return "auto";
-}
-async function setConfiguredProvider(provider, rootDir) {
-  if (!VALID_PROVIDERS.includes(provider)) {
-    throw new Error(`Invalid provider: ${provider}. Valid options: ${VALID_PROVIDERS.join(", ")}`);
-  }
-  const dir = rootDir || process.cwd();
-  const configPath = path.join(dir, ".paradigm", "config.yaml");
-  let config = {};
-  if (fs.existsSync(configPath)) {
-    try {
-      const content = fs.readFileSync(configPath, "utf-8");
-      config = yaml.load(content);
-    } catch {
-    }
-  }
-  config["agent-provider"] = provider;
-  configuredProvider = provider;
-  const paradigmDir = path.dirname(configPath);
-  if (!fs.existsSync(paradigmDir)) {
-    fs.mkdirSync(paradigmDir, { recursive: true });
-  }
-  fs.writeFileSync(configPath, yaml.dump(config));
-}
-async function getBestProvider(rootDir, explicitProvider) {
-  await initializeProviders(rootDir);
-  const configured = explicitProvider || getConfiguredProvider(rootDir);
-  const isExplicit = configured !== "auto";
-  if (isExplicit) {
-    const provider = providers.get(configured);
-    if (provider) {
-      try {
-        const available = await provider.isAvailable();
-        if (available) {
-          return {
-            provider,
-            name: configured,
-            reason: `Configured: ${getProviderReason(configured)}`,
-            configured: true
-          };
-        }
-      } catch {
-      }
-      console.warn(`Configured provider '${configured}' not available, falling back...`);
-    }
-  }
-  for (const name of PROVIDER_PRIORITY) {
-    const provider = providers.get(name);
-    if (!provider) continue;
-    try {
-      const available = await provider.isAvailable();
-      if (available) {
-        return {
-          provider,
-          name,
-          reason: isExplicit ? `Fallback: ${getProviderReason(name)} (configured '${configured}' unavailable)` : getProviderReason(name),
-          configured: false
-        };
-      }
-    } catch {
-    }
-  }
-  throw new Error("No providers available");
-}
-async function getAvailableProviders(rootDir) {
-  await initializeProviders(rootDir);
-  const results = [];
-  for (const name of PROVIDER_PRIORITY) {
-    const provider = providers.get(name);
-    if (!provider) continue;
-    let available = false;
-    try {
-      available = await provider.isAvailable();
-    } catch {
-    }
-    results.push({
-      name,
-      available,
-      reason: available ? getProviderReason(name) : getProviderUnavailableReason(name),
-      features: {
-        parallel: provider.supportsParallel(),
-        mcp: provider.supportsMcp(),
-        billing: getProviderBilling(name)
-      }
-    });
-  }
-  return results;
-}
-async function initializeProviders(rootDir) {
-  if (initialized) return;
-  const dir = rootDir || process.cwd();
-  try {
-    const { ClaudeAgentProvider } = await import("./claude-FRRWJSTJ.js");
-    registerProvider(new ClaudeAgentProvider());
-  } catch {
-  }
-  try {
-    const { ClaudeCodeTeamsProvider } = await import("./claude-code-teams-T4SP24MD.js");
-    registerProvider(new ClaudeCodeTeamsProvider(dir));
-  } catch {
-  }
-  try {
-    const { ClaudeCodeTaskProvider } = await import("./claude-code-HTBA4XRB.js");
-    registerProvider(new ClaudeCodeTaskProvider(dir));
-  } catch {
-  }
-  try {
-    const { CursorCliProvider } = await import("./cursor-cli-JVEZGHWQ.js");
-    registerProvider(new CursorCliProvider());
-  } catch {
-  }
-  try {
-    const { ClaudeCliProvider } = await import("./claude-cli-XJLK2X4L.js");
-    registerProvider(new ClaudeCliProvider());
-  } catch {
-  }
-  try {
-    const { ManualProvider } = await import("./manual-G6FISID5.js");
-    registerProvider(new ManualProvider(dir));
-  } catch {
-  }
-  for (const name of PROVIDER_PRIORITY) {
-    const provider = providers.get(name);
-    if (provider) {
-      try {
-        const available = await provider.isAvailable();
-        if (available) {
-          defaultProviderName = name;
-          break;
-        }
-      } catch {
-      }
-    }
-  }
-  if (!defaultProviderName && providers.has("manual")) {
-    defaultProviderName = "manual";
-  }
-  initialized = true;
-}
-function getProviderReason(name) {
-  switch (name) {
-    case "claude":
-      return "Using Anthropic API (ANTHROPIC_API_KEY found)";
-    case "claude-code-teams":
-      return "Using Claude Code Agent Teams (experimental, parallel teammates)";
-    case "claude-code":
-      return "Using Claude Code Task tool (running in Claude Code)";
-    case "cursor-cli":
-      return "Using Cursor agent CLI (running in Cursor)";
-    case "claude-cli":
-      return "Using Claude CLI (claude command found)";
-    case "manual":
-      return "Using manual handoff (no automation available)";
-    default:
-      return "Unknown provider";
-  }
-}
-function getProviderUnavailableReason(name) {
-  switch (name) {
-    case "claude":
-      return "ANTHROPIC_API_KEY not set";
-    case "claude-code-teams":
-      return "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS not set or not in Claude Code";
-    case "claude-code":
-      return "Not running inside Claude Code";
-    case "cursor-cli":
-      return "Not running in Cursor or agent CLI not found";
-    case "claude-cli":
-      return "claude CLI not found in PATH";
-    case "manual":
-      return "Should always be available";
-    default:
-      return "Unknown";
-  }
-}
-function getProviderBilling(name) {
-  switch (name) {
-    case "claude":
-      return "api";
-    case "claude-code-teams":
-    case "claude-code":
-    case "cursor-cli":
-    case "claude-cli":
-      return "subscription";
-    case "manual":
-      return "none";
-    default:
-      return "none";
-  }
-}
-
-export {
-  getProvider,
-  getConfiguredProvider,
-  setConfiguredProvider,
-  getBestProvider,
-  getAvailableProviders,
-  initializeProviders
-};