@visulima/vis 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/packem_shared/_commonjsHelpers-BqLXS_qQ.js

@@ -1,5 +0,0 @@
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-
-export { getDefaultExportFromCjs as g };

package/dist/packem_shared/ai-analysis-CHeB1joD.js

@@ -1,367 +0,0 @@
-import { runProvider, PROVIDER_NAMES, detectProvider, detectAvailableProviders } from '@visulima/find-ai-runner';
-import { renderToString, Box, Text, Table } from '@visulima/tui';
-import React from 'react';
-import { b as buildCacheKey, a as getCachedAnalysis, s as setCachedAnalysis, d as getTtlForAnalysisType } from './ai-cache-Be_jexe4.js';
-
-const AI_TIMEOUT_MS = 12e4;
-const MAX_RETRIES = 2;
-const RETRY_BASE_DELAY_MS = 1e3;
-const sleep = (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
-});
-const runWithRetry = async (provider, prompt, retries = MAX_RETRIES) => {
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt += 1) {
-    try {
-      const result = await runProvider(provider, prompt, { timeoutMs: AI_TIMEOUT_MS });
-      return result.stdout;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (lastError.message.includes("timed out")) {
-        throw lastError;
-      }
-      if (attempt < retries) {
-        const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
-        await sleep(delay);
-      }
-    }
-  }
-  throw lastError ?? new Error("AI request failed after retries");
-};
-
-const DEFAULT_PRIORITY = {
-  amp: 30,
-  claude: 80,
-  codex: 60,
-  copilot: 50,
-  crush: 35,
-  cursor: 40,
-  droid: 20,
-  gemini: 100,
-  kimi: 25,
-  opencode: 35,
-  qwen: 30
-};
-const resolveProvider = (config) => {
-  if (config?.provider) {
-    if (!PROVIDER_NAMES.includes(config.provider)) {
-      return void 0;
-    }
-    const provider = detectProvider(config.provider);
-    return provider.available ? provider : void 0;
-  }
-  const available = detectAvailableProviders();
-  if (available.length === 0) {
-    return void 0;
-  }
-  const priority = { ...DEFAULT_PRIORITY, ...config?.priority };
-  return available.toSorted((a, b) => (priority[b.name] ?? 0) - (priority[a.name] ?? 0))[0];
-};
-const VALID_ACTIONS = /* @__PURE__ */ new Set(["defer", "review", "skip", "update"]);
-const VALID_RISK_LEVELS = /* @__PURE__ */ new Set(["critical", "high", "low", "medium"]);
-const VALID_EFFORTS = /* @__PURE__ */ new Set(["high", "low", "medium"]);
-const CHUNK_THRESHOLD = 50;
-const CHUNK_SIZE = 30;
-const buildPackageList = (outdated) => outdated.map((entry) => {
-  const vulnInfo = entry.vulnerabilities && entry.vulnerabilities.length > 0 ? ` [VULNERABILITIES: ${entry.vulnerabilities.map((v) => `${v.severity} ${v.id}`).join(", ")}]` : "";
-  let socketInfo = "";
-  if (entry.socketReport) {
-    const score = Math.round(entry.socketReport.score.overall * 100);
-    const parts = [`score:${String(score)}%`];
-    if (entry.socketReport.alerts.length > 0) {
-      const alertsByLevel = entry.socketReport.alerts.reduce((accumulator, a) => {
-        accumulator[a.severity] = (accumulator[a.severity] ?? 0) + 1;
-        return accumulator;
-      }, {});
-      const alertSummary = Object.entries(alertsByLevel).map(([s, c]) => `${String(c)} ${s}`).join(", ");
-      parts.push(`alerts: ${alertSummary}`);
-    }
-    parts.push(`supply-chain:${String(Math.round(entry.socketReport.score.supplyChain * 100))}%`);
-    parts.push(`quality:${String(Math.round(entry.socketReport.score.quality * 100))}%`);
-    socketInfo = ` [SOCKET.DEV: ${parts.join(", ")}]`;
-  }
-  return `- ${entry.packageName}: ${entry.currentRange} → ${entry.newRange} (${entry.updateType})${vulnInfo}${socketInfo}`;
-}).join("\n");
-const JSON_RESPONSE_SCHEMA = `Respond ONLY with valid JSON in this exact structure:
-{
-  "summary": "Brief overall summary",
-  "recommendations": [
-    {
-      "package": "package-name",
-      "action": "update|skip|review|defer",
-      "reason": "explanation",
-      "riskLevel": "low|medium|high|critical",
-      "breakingChanges": ["change1"],
-      "effort": "low|medium|high"
-    }
-  ],
-  "warnings": ["warning1"]
-}`;
-const PROMPTS = {
-  compatibility: (packageList) => `Analyze the compatibility of these package updates:
-
-${packageList}
-
-For each package:
-1. Check peer dependency compatibility
-2. Identify potential conflicts with other packages in the list
-3. Assess API compatibility between current and target versions
-4. Check for deprecated features being removed
-5. Evaluate Node.js version requirements
-
-${JSON_RESPONSE_SCHEMA}`,
-  impact: (packageList) => `Analyze the impact of updating these npm packages:
-
-${packageList}
-
-For each package, provide:
-1. Risk level (low/medium/high/critical)
-2. Recommended action (update/skip/review/defer)
-3. Reason for recommendation
-4. Known breaking changes (if any)
-5. Estimated migration effort (low/medium/high)
-
-${JSON_RESPONSE_SCHEMA}`,
-  recommend: (packageList) => `Provide smart recommendations for updating these packages:
-
-${packageList}
-
-Consider:
-1. Update priority based on security, features, and stability
-2. Grouping related packages for atomic updates
-3. Best practices for the specific package ecosystem
-4. Risk vs. benefit analysis
-5. Suggested update order
-6. If Socket.dev scores are provided, prioritize packages with low supply chain or quality scores
-
-${JSON_RESPONSE_SCHEMA}`,
-  security: (packageList) => `Analyze the security implications of these package updates:
-
-${packageList}
-
-For each package:
-1. Check if the update fixes known vulnerabilities (use the vulnerability data above)
-2. Assess if the new version introduces security risks
-3. Evaluate if this is a security-sensitive package (auth, crypto, session, etc.)
-4. Recommend urgency of the update based on vulnerability severity
-5. Flag any packages where skipping the update poses security risk
-6. If Socket.dev scores are provided, factor in supply chain and quality scores — low scores indicate higher risk
-
-${JSON_RESPONSE_SCHEMA}`
-};
-const VALID_ANALYSIS_TYPES = /* @__PURE__ */ new Set(["compatibility", "impact", "recommend", "security"]);
-const validateAnalysisType = (type) => {
-  if (VALID_ANALYSIS_TYPES.has(type)) {
-    return type;
-  }
-  return "impact";
-};
-const buildAnalysisPrompt = (outdated, analysisType = "impact") => {
-  const packageList = buildPackageList(outdated);
-  return PROMPTS[analysisType](packageList);
-};
-const JSON_BLOCK_REGEX = /```(?:json)?\s*([\s\S]*?)```/;
-const JSON_OBJECT_REGEX = /\{[\s\S]*\}/;
-const extractJson = (text) => {
-  try {
-    return JSON.parse(text);
-  } catch {
-  }
-  const blockMatch = JSON_BLOCK_REGEX.exec(text);
-  if (blockMatch?.[1]) {
-    try {
-      return JSON.parse(blockMatch[1]);
-    } catch {
-    }
-  }
-  const objectMatch = JSON_OBJECT_REGEX.exec(text);
-  if (objectMatch?.[0]) {
-    try {
-      return JSON.parse(objectMatch[0]);
-    } catch {
-    }
-  }
-  return void 0;
-};
-const normalizeRecommendation = (raw) => {
-  return {
-    action: VALID_ACTIONS.has(raw.action) ? raw.action : "review",
-    breakingChanges: Array.isArray(raw.breakingChanges) ? raw.breakingChanges : [],
-    effort: VALID_EFFORTS.has(raw.effort) ? raw.effort : "medium",
-    package: typeof raw.package === "string" ? raw.package : "",
-    reason: typeof raw.reason === "string" ? raw.reason : "",
-    riskLevel: VALID_RISK_LEVELS.has(raw.riskLevel) ? raw.riskLevel : "medium"
-  };
-};
-const parseAiResponse = (text, provider, analysisType) => {
-  const parsed = extractJson(text);
-  if (!parsed || typeof parsed !== "object") {
-    return { analysisType, provider, recommendations: [], summary: "Failed to parse AI response.", warnings: ["AI response was not valid JSON."] };
-  }
-  const data = parsed;
-  const rawRecs = Array.isArray(data.recommendations) ? data.recommendations : [];
-  return {
-    analysisType,
-    provider,
-    recommendations: rawRecs.map((rec) => normalizeRecommendation(rec)),
-    summary: typeof data.summary === "string" ? data.summary : "",
-    warnings: Array.isArray(data.warnings) ? data.warnings : []
-  };
-};
-const KNOWN_BREAKING = {
-  eslint: ["ESLint 9.0: Flat config required", "ESLint 8.0+: New rule formats"],
-  next: ["Next.js 13+: App router changes", "Next.js 14+: Server components default"],
-  react: ["React 17 to 18: Concurrent features", "React 18+: Strict mode changes"],
-  typescript: ["TypeScript 5.0: New decorators", "TypeScript 4.7+: ESM changes"],
-  vite: ["Vite 5: Node.js 18+ required"],
-  vue: ["Vue 3: Composition API", "Vue 3: Breaking template changes"],
-  webpack: ["Webpack 5: Node.js polyfills removed"]
-};
-const SECURITY_SENSITIVE = /* @__PURE__ */ new Set(["bcrypt", "cors", "crypto-js", "express-session", "helmet", "jose", "jsonwebtoken", "node-forge", "oauth", "passport"]);
-const ruleBasedAnalysis = (outdated, analysisType) => {
-  const recommendations = outdated.map((entry) => {
-    const hasVulnerabilities = entry.vulnerabilities && entry.vulnerabilities.length > 0;
-    const isSecuritySensitive = SECURITY_SENSITIVE.has(entry.packageName);
-    const breakingChanges = KNOWN_BREAKING[entry.packageName] ?? [];
-    let riskLevel = "low";
-    let action = "update";
-    let effort = "low";
-    let reason = "Patch/minor update, safe to apply.";
-    if (entry.updateType === "major") {
-      riskLevel = "high";
-      action = breakingChanges.length > 0 ? "review" : "update";
-      effort = "medium";
-      reason = breakingChanges.length > 0 ? `Major update with known breaking changes: ${breakingChanges[0]}` : "Major version update, review changelog before applying.";
-    } else if (entry.updateType === "minor") {
-      riskLevel = "medium";
-      reason = "Minor update, generally safe.";
-    }
-    if (hasVulnerabilities) {
-      riskLevel = "high";
-      action = "update";
-      reason = "Security update — current version has known vulnerabilities.";
-    }
-    if (isSecuritySensitive && entry.updateType === "major") {
-      action = "review";
-      reason = "Security-sensitive package with major update, careful review needed.";
-      effort = "high";
-    }
-    return { action, breakingChanges, effort, package: entry.packageName, reason, riskLevel };
-  });
-  return {
-    analysisType,
-    provider: "rule-engine",
-    recommendations,
-    summary: `Rule-based ${analysisType} analysis for ${String(outdated.length)} packages.`,
-    warnings: ["No AI provider available — using built-in rule engine."]
-  };
-};
-const analyzeChunk = async (provider, chunk, analysisType) => {
-  const prompt = buildAnalysisPrompt(chunk, analysisType);
-  const stdout = await runWithRetry(provider, prompt);
-  return parseAiResponse(stdout, provider.name, analysisType);
-};
-const mergeResults = (results, provider, analysisType) => {
-  const recommendations = [];
-  const warnings = [];
-  const summaries = [];
-  for (const result of results) {
-    recommendations.push(...result.recommendations);
-    warnings.push(...result.warnings);
-    if (result.summary) {
-      summaries.push(result.summary);
-    }
-  }
-  return {
-    analysisType,
-    provider,
-    recommendations,
-    summary: summaries.length === 1 ? summaries[0] ?? "" : `Analyzed ${String(recommendations.length)} packages in ${String(results.length)} batches.`,
-    warnings: [...new Set(warnings)]
-  };
-};
-const ANALYSIS_TYPE_LABELS = {
-  compatibility: "Compatibility",
-  impact: "Impact",
-  recommend: "Recommendations",
-  security: "Security"
-};
-const formatAiAnalysis = (result) => {
-  const typeLabel = ANALYSIS_TYPE_LABELS[result.analysisType] ?? result.analysisType;
-  const header = `${typeLabel} Analysis (${result.provider})`;
-  const tableData = result.recommendations.flatMap((rec) => {
-    const rows = [
-      { action: rec.action, effort: rec.effort, package: rec.package, reason: rec.reason, risk: rec.riskLevel }
-    ];
-    if (rec.breakingChanges.length > 0) {
-      rows.push({ action: "", effort: "", package: "", reason: `Breaking: ${rec.breakingChanges.join("; ")}`, risk: "" });
-    }
-    return rows;
-  });
-  const columns = process.stdout.columns || 80;
-  return renderToString(
-    React.createElement(
-      Box,
-      { borderStyle: "round", flexDirection: "column", paddingLeft: 1, paddingRight: 1 },
-      React.createElement(Text, { bold: true }, header),
-      React.createElement(Text, null, ""),
-      React.createElement(Text, null, result.summary),
-      React.createElement(Text, null, ""),
-      React.createElement(Table, { borderStyle: "none", data: tableData }),
-      ...result.warnings.length > 0 ? [
-        React.createElement(Text, null, ""),
-        ...result.warnings.map((warning, i) => React.createElement(Text, { dimColor: true, key: String(i) }, `  ${warning}`))
-      ] : []
-    ),
-    { columns }
-  );
-};
-const runAiAnalysis = async (outdated, logger, config, analysisType = "impact") => {
-  const provider = resolveProvider(config);
-  if (!provider) {
-    logger.info("No AI CLI tool found, using rule-based analysis.\n");
-    return ruleBasedAnalysis(outdated, analysisType);
-  }
-  const cacheKey = buildCacheKey(provider.name, analysisType, outdated);
-  const cached = getCachedAnalysis(cacheKey);
-  if (cached) {
-    logger.info(`Using cached ${analysisType} analysis from ${cached.provider}.
-`);
-    return cached;
-  }
-  const typeLabel = ANALYSIS_TYPE_LABELS[analysisType] ?? analysisType;
-  logger.info(`Running ${typeLabel.toLowerCase()} analysis with ${provider.name}...
-`);
-  try {
-    let result;
-    if (outdated.length > CHUNK_THRESHOLD) {
-      logger.info(`Splitting ${String(outdated.length)} packages into batches of ${String(CHUNK_SIZE)}...
-`);
-      const chunks = [];
-      for (let index = 0; index < outdated.length; index += CHUNK_SIZE) {
-        chunks.push(outdated.slice(index, index + CHUNK_SIZE));
-      }
-      const results = [];
-      for (let index = 0; index < chunks.length; index += 1) {
-        logger.info(`  Batch ${String(index + 1)}/${String(chunks.length)}...`);
-        const chunk = chunks[index];
-        if (chunk) {
-          results.push(await analyzeChunk(provider, chunk, analysisType));
-        }
-      }
-      result = mergeResults(results, provider.name, analysisType);
-    } else {
-      const stdout = await runWithRetry(provider, buildAnalysisPrompt(outdated, analysisType));
-      result = parseAiResponse(stdout, provider.name, analysisType);
-    }
-    setCachedAnalysis(cacheKey, result, getTtlForAnalysisType(analysisType, config?.cacheTtl));
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn(`AI analysis failed (${message}), falling back to rule engine.
-`);
-    return ruleBasedAnalysis(outdated, analysisType);
-  }
-};
-
-export { DEFAULT_PRIORITY as D, resolveProvider as a, runWithRetry as b, extractJson as e, formatAiAnalysis as f, runAiAnalysis as r, validateAnalysisType as v };

package/dist/packem_shared/ai-cache-Be_jexe4.js

@@ -1,142 +0,0 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-const {
-  rmSync,
-  writeFileSync,
-  readdirSync,
-  statSync
-} = __cjs_getBuiltinModule("node:fs");
-const {
-  homedir
-} = __cjs_getBuiltinModule("node:os");
-import { x as xxh3Hash } from './xxh3-Ck8mXNg1.js';
-import { isAccessibleSync, readJsonSync, ensureDirSync } from '@visulima/fs';
-import { join } from '@visulima/path';
-
-const getCacheDirectory = () => join(homedir(), ".vis", "cache", "ai");
-const DEFAULT_TTL_MS = 60 * 60 * 1e3;
-const SECURITY_TTL_MS = 30 * 60 * 1e3;
-const ensureCacheDirectory = () => {
-  ensureDirSync(getCacheDirectory());
-};
-const buildCacheKey = (provider, analysisType, outdated) => {
-  const packages = outdated.map((entry) => {
-    return { currentRange: entry.currentRange, name: entry.packageName, targetVersion: entry.targetVersion };
-  }).toSorted((a, b) => a.name.localeCompare(b.name));
-  const payload = JSON.stringify({ analysisType, packages, provider });
-  return xxh3Hash(Buffer.from(payload));
-};
-const getCachedAnalysis = (cacheKey) => {
-  const filePath = join(getCacheDirectory(), `${cacheKey}.json`);
-  if (!isAccessibleSync(filePath)) {
-    return void 0;
-  }
-  try {
-    const entry = readJsonSync(filePath);
-    if (Date.now() - entry.createdAt > entry.ttlMs) {
-      rmSync(filePath, { force: true });
-      return void 0;
-    }
-    return entry.result;
-  } catch {
-    rmSync(filePath, { force: true });
-    return void 0;
-  }
-};
-const setCachedAnalysis = (cacheKey, result, ttlMs) => {
-  ensureCacheDirectory();
-  const cacheDirectory = getCacheDirectory();
-  const entry = {
-    createdAt: Date.now(),
-    result,
-    ttlMs
-  };
-  writeFileSync(join(cacheDirectory, `${cacheKey}.json`), JSON.stringify(entry, void 0, 2), "utf8");
-};
-const getTtlForAnalysisType = (analysisType, configTtl) => {
-  if (configTtl !== void 0 && configTtl > 0) {
-    return configTtl;
-  }
-  return analysisType === "security" ? SECURITY_TTL_MS : DEFAULT_TTL_MS;
-};
-const getCacheStats = () => {
-  const cacheDirectory = getCacheDirectory();
-  if (!isAccessibleSync(cacheDirectory)) {
-    return { entries: 0, newestEntry: void 0, oldestEntry: void 0, totalSizeBytes: 0 };
-  }
-  const files = readdirSync(cacheDirectory).filter((f) => f.endsWith(".json"));
-  let totalSizeBytes = 0;
-  let oldest;
-  let newest;
-  for (const file of files) {
-    const filePath = join(cacheDirectory, file);
-    const stat = statSync(filePath);
-    totalSizeBytes += stat.size;
-    const { mtimeMs } = stat;
-    if (oldest === void 0 || mtimeMs < oldest) {
-      oldest = mtimeMs;
-    }
-    if (newest === void 0 || mtimeMs > newest) {
-      newest = mtimeMs;
-    }
-  }
-  return { entries: files.length, newestEntry: newest, oldestEntry: oldest, totalSizeBytes };
-};
-const buildHashCacheKey = (payload) => xxh3Hash(Buffer.from(JSON.stringify(payload)));
-const getCachedJson = (cacheKey) => {
-  const filePath = join(getCacheDirectory(), `${cacheKey}.json`);
-  if (!isAccessibleSync(filePath)) {
-    return void 0;
-  }
-  try {
-    const entry = readJsonSync(filePath);
-    if (Date.now() - entry.createdAt > entry.ttlMs) {
-      rmSync(filePath, { force: true });
-      return void 0;
-    }
-    return entry.result;
-  } catch {
-    rmSync(filePath, { force: true });
-    return void 0;
-  }
-};
-const setCachedJson = (cacheKey, result, ttlMs) => {
-  ensureCacheDirectory();
-  const cacheDirectory = getCacheDirectory();
-  const entry = {
-    createdAt: Date.now(),
-    result,
-    ttlMs
-  };
-  writeFileSync(join(cacheDirectory, `${cacheKey}.json`), JSON.stringify(entry, void 0, 2), "utf8");
-};
-const clearCache = () => {
-  const cacheDirectory = getCacheDirectory();
-  if (!isAccessibleSync(cacheDirectory)) {
-    return 0;
-  }
-  const files = readdirSync(cacheDirectory).filter((f) => f.endsWith(".json"));
-  for (const file of files) {
-    rmSync(join(cacheDirectory, file), { force: true });
-  }
-  return files.length;
-};
-
-export { getCachedAnalysis as a, buildCacheKey as b, clearCache as c, getTtlForAnalysisType as d, getCachedJson as e, setCachedJson as f, getCacheStats as g, buildHashCacheKey as h, setCachedAnalysis as s };