shiva-code 0.2.2 → 0.3.0

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
+};

package/dist/github-R3I7U2DQ.js

@@ -0,0 +1,49 @@
+import {
+  findMentionedIssueNumbers,
+  formatContextAsMarkdown,
+  generateGitHubContext,
+  getCIStatus,
+  getCurrentBranch,
+  getGhUser,
+  getGitHubRemote,
+  getIssue,
+  getOpenIssues,
+  getOpenPRs,
+  getPR,
+  getPRForBranch,
+  getRecentCommits,
+  getRepoInfo,
+  invalidateGitHubCache,
+  isGhAuthenticated,
+  isGhInstalled,
+  isGitHubRepo,
+  isGitRepo,
+  parseGitHubUrl,
+  runGh,
+  runGhRaw
+} from "./chunk-66D4NGIK.js";
+import "./chunk-G2G6UUWM.js";
+export {
+  findMentionedIssueNumbers,
+  formatContextAsMarkdown,
+  generateGitHubContext,
+  getCIStatus,
+  getCurrentBranch,
+  getGhUser,
+  getGitHubRemote,
+  getIssue,
+  getOpenIssues,
+  getOpenPRs,
+  getPR,
+  getPRForBranch,
+  getRecentCommits,
+  getRepoInfo,
+  invalidateGitHubCache,
+  isGhAuthenticated,
+  isGhInstalled,
+  isGitHubRepo,
+  isGitRepo,
+  parseGitHubUrl,
+  runGh,
+  runGhRaw
+};