shiva-code 0.2.2 → 0.4.1

package/dist/chunk-G2G6UUWM.js

@@ -0,0 +1,169 @@
+// src/services/cache.ts
+var CacheService = class _CacheService {
+  cache;
+  // Default TTLs in milliseconds
+  static TTL = {
+    SESSIONS: 30 * 1e3,
+    // 30 seconds for sessions
+    GITHUB_ISSUES: 5 * 60 * 1e3,
+    // 5 minutes for GitHub issues
+    GITHUB_PRS: 5 * 60 * 1e3,
+    // 5 minutes for GitHub PRs
+    GITHUB_CONTEXT: 5 * 60 * 1e3,
+    // 5 minutes for full context
+    TERMINAL: 24 * 60 * 60 * 1e3
+    // 24 hours for terminal detection
+  };
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get a cached value
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Set a cached value with TTL
+   */
+  set(key, data, ttlMs) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl: ttlMs
+    });
+  }
+  /**
+   * Invalidate a specific key
+   */
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Invalidate all keys matching a pattern
+   */
+  invalidatePattern(pattern) {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+    for (const key of this.cache.keys()) {
+      if (regex.test(key)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Clear the entire cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  stats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  // ============================================
+  // Session-specific methods
+  // ============================================
+  /**
+   * Get cached Claude projects (sessions)
+   */
+  getSessions() {
+    return this.get("sessions:all");
+  }
+  /**
+   * Set cached Claude projects (sessions)
+   */
+  setSessions(projects) {
+    this.set("sessions:all", projects, _CacheService.TTL.SESSIONS);
+  }
+  /**
+   * Invalidate sessions cache
+   */
+  invalidateSessions() {
+    this.invalidatePattern("sessions:*");
+  }
+  // ============================================
+  // GitHub-specific methods
+  // ============================================
+  /**
+   * Get cached GitHub issues for a repo
+   */
+  getGitHubIssues(repo) {
+    return this.get(`github:issues:${repo}`);
+  }
+  /**
+   * Set cached GitHub issues for a repo
+   */
+  setGitHubIssues(repo, issues) {
+    this.set(`github:issues:${repo}`, issues, _CacheService.TTL.GITHUB_ISSUES);
+  }
+  /**
+   * Get cached GitHub PRs for a repo
+   */
+  getGitHubPRs(repo) {
+    return this.get(`github:prs:${repo}`);
+  }
+  /**
+   * Set cached GitHub PRs for a repo
+   */
+  setGitHubPRs(repo, prs) {
+    this.set(`github:prs:${repo}`, prs, _CacheService.TTL.GITHUB_PRS);
+  }
+  /**
+   * Get cached GitHub context for a project
+   */
+  getGitHubContext(projectPath) {
+    return this.get(`github:context:${projectPath}`);
+  }
+  /**
+   * Set cached GitHub context for a project
+   */
+  setGitHubContext(projectPath, context) {
+    this.set(`github:context:${projectPath}`, context, _CacheService.TTL.GITHUB_CONTEXT);
+  }
+  /**
+   * Invalidate all GitHub caches
+   */
+  invalidateGitHub() {
+    this.invalidatePattern("github:*");
+  }
+  /**
+   * Invalidate GitHub caches for a specific repo
+   */
+  invalidateGitHubRepo(repo) {
+    this.invalidate(`github:issues:${repo}`);
+    this.invalidate(`github:prs:${repo}`);
+  }
+  // ============================================
+  // Terminal detection cache
+  // ============================================
+  /**
+   * Get cached detected terminal
+   */
+  getDetectedTerminal() {
+    return this.get("terminal:detected");
+  }
+  /**
+   * Set cached detected terminal
+   */
+  setDetectedTerminal(terminal) {
+    this.set("terminal:detected", terminal, _CacheService.TTL.TERMINAL);
+  }
+};
+var cache = new CacheService();
+
+export {
+  cache
+};

package/dist/chunk-GHAT2D55.js

@@ -0,0 +1,175 @@
+import {
+  findProject,
+  getProjectName
+} from "./chunk-MDMZWOX7.js";
+
+// src/services/package-manager.ts
+import Conf from "conf";
+import * as fs from "fs";
+import * as path from "path";
+var packageStore = new Conf({
+  projectName: "shiva-code",
+  configName: "packages",
+  defaults: {
+    packages: {}
+  }
+});
+function getAllPackages() {
+  const packages = packageStore.get("packages") || {};
+  return Object.values(packages).sort(
+    (a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime()
+  );
+}
+function getPackage(name) {
+  const packages = packageStore.get("packages") || {};
+  return packages[name.toLowerCase()] || null;
+}
+function createPackage(name, description, launchOrder = "parallel") {
+  const packages = packageStore.get("packages") || {};
+  const key = name.toLowerCase();
+  if (packages[key]) {
+    throw new Error(`Package "${name}" existiert bereits`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newPackage = {
+    name,
+    description,
+    projects: [],
+    created: now,
+    modified: now,
+    launchOrder
+  };
+  packages[key] = newPackage;
+  packageStore.set("packages", packages);
+  return newPackage;
+}
+function updatePackage(name, updates) {
+  const packages = packageStore.get("packages") || {};
+  const key = name.toLowerCase();
+  const existing = packages[key];
+  if (!existing) {
+    throw new Error(`Package "${name}" nicht gefunden`);
+  }
+  if (updates.name && updates.name.toLowerCase() !== key) {
+    const newKey = updates.name.toLowerCase();
+    if (packages[newKey]) {
+      throw new Error(`Package "${updates.name}" existiert bereits`);
+    }
+    delete packages[key];
+    packages[newKey] = {
+      ...existing,
+      ...updates,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    packageStore.set("packages", packages);
+    return packages[newKey];
+  }
+  packages[key] = {
+    ...existing,
+    ...updates,
+    modified: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  packageStore.set("packages", packages);
+  return packages[key];
+}
+function deletePackage(name) {
+  const packages = packageStore.get("packages") || {};
+  const key = name.toLowerCase();
+  if (!packages[key]) {
+    throw new Error(`Package "${name}" nicht gefunden`);
+  }
+  delete packages[key];
+  packageStore.set("packages", packages);
+}
+function addProjectToPackage(packageName, projectPath) {
+  const packages = packageStore.get("packages") || {};
+  const key = packageName.toLowerCase();
+  const pkg = packages[key];
+  if (!pkg) {
+    throw new Error(`Package "${packageName}" nicht gefunden`);
+  }
+  const absolutePath = path.resolve(projectPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Pfad existiert nicht: ${absolutePath}`);
+  }
+  if (pkg.projects.includes(absolutePath)) {
+    throw new Error(`Projekt bereits in Package: ${getProjectName(absolutePath)}`);
+  }
+  pkg.projects.push(absolutePath);
+  pkg.modified = (/* @__PURE__ */ new Date()).toISOString();
+  packageStore.set("packages", packages);
+  return pkg;
+}
+function removeProjectFromPackage(packageName, projectPath) {
+  const packages = packageStore.get("packages") || {};
+  const key = packageName.toLowerCase();
+  const pkg = packages[key];
+  if (!pkg) {
+    throw new Error(`Package "${packageName}" nicht gefunden`);
+  }
+  const absolutePath = path.resolve(projectPath);
+  const projectName = getProjectName(projectPath);
+  const index = pkg.projects.findIndex(
+    (p) => p === absolutePath || getProjectName(p).toLowerCase() === projectName.toLowerCase()
+  );
+  if (index === -1) {
+    throw new Error(`Projekt nicht in Package: ${projectPath}`);
+  }
+  pkg.projects.splice(index, 1);
+  pkg.modified = (/* @__PURE__ */ new Date()).toISOString();
+  packageStore.set("packages", packages);
+  return pkg;
+}
+async function getPackageLaunchConfig(packageName, newSessions = false) {
+  const pkg = getPackage(packageName);
+  if (!pkg) {
+    throw new Error(`Package "${packageName}" nicht gefunden`);
+  }
+  const launches = [];
+  for (const projectPath of pkg.projects) {
+    if (!fs.existsSync(projectPath)) {
+      console.warn(`Skipping non-existent path: ${projectPath}`);
+      continue;
+    }
+    const project = await findProject(projectPath);
+    const latestSession = project?.latestSession;
+    launches.push({
+      projectPath,
+      projectName: getProjectName(projectPath),
+      sessionId: newSessions ? void 0 : latestSession?.sessionId,
+      newSession: newSessions || !latestSession
+    });
+  }
+  return launches;
+}
+function findPackagesWithProject(projectPath) {
+  const absolutePath = path.resolve(projectPath);
+  const packages = getAllPackages();
+  return packages.filter(
+    (pkg) => pkg.projects.some(
+      (p) => p === absolutePath || getProjectName(p).toLowerCase() === getProjectName(projectPath).toLowerCase()
+    )
+  );
+}
+function getPackageStats() {
+  const packages = getAllPackages();
+  const totalProjects = packages.reduce((sum, pkg) => sum + pkg.projects.length, 0);
+  return {
+    totalPackages: packages.length,
+    totalProjects,
+    averageProjectsPerPackage: packages.length > 0 ? Math.round(totalProjects / packages.length * 10) / 10 : 0
+  };
+}
+
+export {
+  getAllPackages,
+  getPackage,
+  createPackage,
+  updatePackage,
+  deletePackage,
+  addProjectToPackage,
+  removeProjectFromPackage,
+  getPackageLaunchConfig,
+  findPackagesWithProject,
+  getPackageStats
+};

package/dist/chunk-MDMZWOX7.js

@@ -0,0 +1,304 @@
+import {
+  cache
+} from "./chunk-G2G6UUWM.js";
+
+// src/services/session-manager.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+function getClaudeProjectsPath() {
+  return path.join(os.homedir(), ".claude", "projects");
+}
+function encodeProjectPath(projectPath) {
+  return projectPath.replace(/\//g, "-").replace(/^-/, "");
+}
+function decodeProjectPath(encoded) {
+  const parts = encoded.split("-").filter(Boolean);
+  return "/" + parts.join("/");
+}
+function getProjectName(projectPath) {
+  return path.basename(projectPath);
+}
+async function getAllClaudeProjects(skipCache = false) {
+  if (!skipCache) {
+    const cached = cache.getSessions();
+    if (cached) {
+      return cached;
+    }
+  }
+  const projectsPath = getClaudeProjectsPath();
+  if (!fs.existsSync(projectsPath)) {
+    return [];
+  }
+  const projects = [];
+  const entries = fs.readdirSync(projectsPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const encodedPath = entry.name;
+    const absolutePath = decodeProjectPath(encodedPath);
+    const projectName = getProjectName(absolutePath);
+    const sessionIndex = getSessionIndex(encodedPath);
+    const sessions = sessionIndex?.entries || [];
+    sessions.sort(
+      (a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime()
+    );
+    projects.push({
+      encodedPath,
+      absolutePath,
+      projectName,
+      sessions,
+      latestSession: sessions[0]
+    });
+  }
+  projects.sort((a, b) => {
+    const aTime = a.latestSession ? new Date(a.latestSession.modified).getTime() : 0;
+    const bTime = b.latestSession ? new Date(b.latestSession.modified).getTime() : 0;
+    return bTime - aTime;
+  });
+  cache.setSessions(projects);
+  return projects;
+}
+function invalidateSessionsCache() {
+  cache.invalidateSessions();
+}
+function getSessionIndex(encodedPath) {
+  const indexPath = path.join(
+    getClaudeProjectsPath(),
+    encodedPath,
+    "sessions-index.json"
+  );
+  if (!fs.existsSync(indexPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(indexPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function findProject(nameOrPath) {
+  const projects = await getAllClaudeProjects();
+  const absolutePath = path.resolve(nameOrPath);
+  const byPath = projects.find((p) => p.absolutePath === absolutePath);
+  if (byPath) return byPath;
+  const lowerName = nameOrPath.toLowerCase();
+  const byName = projects.find(
+    (p) => p.projectName.toLowerCase() === lowerName || p.projectName.toLowerCase().includes(lowerName)
+  );
+  return byName || null;
+}
+function findSessionByBranch(project, branch) {
+  const branchSessions = project.sessions.filter((s) => s.gitBranch === branch);
+  if (branchSessions.length === 0) {
+    return null;
+  }
+  return branchSessions[0];
+}
+async function findProjectForCurrentDir() {
+  const cwd = process.cwd();
+  return findProject(cwd);
+}
+function getSessionFilePath(session) {
+  return session.fullPath;
+}
+function isSessionCorrupted(session) {
+  const filePath = getSessionFilePath(session);
+  if (!fs.existsSync(filePath)) {
+    return true;
+  }
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.size > 100 * 1024 * 1024) {
+      return true;
+    }
+    const fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
+    fs.closeSync(fd);
+    if (bytesRead === 0) {
+      return true;
+    }
+    const firstLine = buffer.toString("utf-8").split("\n")[0];
+    JSON.parse(firstLine);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function isSessionActive(session) {
+  const filePath = getSessionFilePath(session);
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  try {
+    const stats = fs.statSync(filePath);
+    return Date.now() - stats.mtimeMs < 3e4;
+  } catch {
+    return false;
+  }
+}
+async function parseSessionFile(jsonlPath, level = "standard") {
+  const summaries = [];
+  if (!fs.existsSync(jsonlPath)) {
+    return summaries;
+  }
+  return new Promise((resolve2) => {
+    const fileStream = fs.createReadStream(jsonlPath, { encoding: "utf-8" });
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let lineCount = 0;
+    const maxLines = level === "minimal" ? 1e3 : level === "standard" ? 1e4 : Infinity;
+    rl.on("line", (line) => {
+      lineCount++;
+      if (lineCount > maxLines) {
+        rl.close();
+        return;
+      }
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "summary") {
+          summaries.push({
+            type: "summary",
+            content: entry.summary || entry.content || "",
+            timestamp: entry.timestamp
+          });
+        }
+        if (level === "full") {
+          if (entry.type === "user" && entry.message?.content) {
+            const content = typeof entry.message.content === "string" ? entry.message.content : JSON.stringify(entry.message.content);
+            summaries.push({
+              type: "user",
+              content: content.substring(0, 500),
+              timestamp: entry.timestamp
+            });
+          }
+        }
+      } catch {
+      }
+    });
+    rl.on("close", () => {
+      resolve2(summaries);
+    });
+    rl.on("error", () => {
+      resolve2(summaries);
+    });
+  });
+}
+async function getRecoveredContext(session, level = "standard") {
+  const summaries = await parseSessionFile(session.fullPath, level);
+  const summaryTexts = summaries.filter((s) => s.type === "summary").map((s) => s.content).filter(Boolean);
+  const filteredSummaries = level === "minimal" ? summaryTexts.slice(-5) : summaryTexts;
+  return {
+    projectPath: session.projectPath,
+    summaries: filteredSummaries,
+    firstPrompt: session.firstPrompt,
+    lastModified: session.modified,
+    messageCount: session.messageCount,
+    gitBranch: session.gitBranch
+  };
+}
+function formatRecoveredContextAsMarkdown(context) {
+  const lines = [];
+  lines.push("# Session Recovery Context");
+  lines.push("");
+  lines.push(`**Project:** ${context.projectPath}`);
+  lines.push(`**Branch:** ${context.gitBranch}`);
+  lines.push(`**Last Modified:** ${context.lastModified}`);
+  lines.push(`**Messages:** ~${context.messageCount}`);
+  lines.push("");
+  if (context.firstPrompt) {
+    lines.push("## Original Task");
+    lines.push("");
+    lines.push(context.firstPrompt);
+    lines.push("");
+  }
+  if (context.summaries.length > 0) {
+    lines.push("## Session Summaries");
+    lines.push("");
+    for (const summary of context.summaries) {
+      lines.push("---");
+      lines.push("");
+      lines.push(summary);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function saveRecoveredContext(context, outputDir) {
+  const dir = outputDir || path.join(os.homedir(), ".shiva", "recovery");
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const projectSlug = getProjectName(context.projectPath).toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const filename = `${projectSlug}-${date}.md`;
+  const filepath = path.join(dir, filename);
+  const content = formatRecoveredContextAsMarkdown(context);
+  fs.writeFileSync(filepath, content, "utf-8");
+  return filepath;
+}
+async function getSessionStats() {
+  const projects = await getAllClaudeProjects();
+  let totalSessions = 0;
+  let activeProjects = 0;
+  for (const project of projects) {
+    totalSessions += project.sessions.length;
+    if (project.sessions.length > 0) {
+      activeProjects++;
+    }
+  }
+  return {
+    totalProjects: projects.length,
+    totalSessions,
+    activeProjects
+  };
+}
+function formatRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const then = new Date(date);
+  const diffMs = now.getTime() - then.getTime();
+  const minutes = Math.floor(diffMs / (1e3 * 60));
+  const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (minutes < 1) return "gerade eben";
+  if (minutes < 60) return `${minutes}m`;
+  if (hours < 24) return `${hours}h`;
+  if (days < 7) return `${days}d`;
+  return then.toLocaleDateString("de-DE", { month: "short", day: "numeric" });
+}
+function formatDate(date) {
+  const d = new Date(date);
+  return d.toLocaleDateString("de-DE", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+
+export {
+  getClaudeProjectsPath,
+  encodeProjectPath,
+  decodeProjectPath,
+  getProjectName,
+  getAllClaudeProjects,
+  invalidateSessionsCache,
+  getSessionIndex,
+  findProject,
+  findSessionByBranch,
+  findProjectForCurrentDir,
+  getSessionFilePath,
+  isSessionCorrupted,
+  isSessionActive,
+  parseSessionFile,
+  getRecoveredContext,
+  formatRecoveredContextAsMarkdown,
+  saveRecoveredContext,
+  getSessionStats,
+  formatRelativeTime,
+  formatDate
+};