shiva-code 0.2.2 → 0.3.0

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-KXYP4OCK.js

@@ -0,0 +1,236 @@
+// src/services/project-config.ts
+import * as fs from "fs";
+import * as path from "path";
+var SHIVA_DIR = ".shiva";
+var CONFIG_FILE = "config.json";
+var SESSIONS_DIR = "sessions";
+var CONTEXT_DIR = "context";
+var GITHUB_CONTEXT_FILE = "github.md";
+var DEFAULT_CONFIG = {
+  version: 1,
+  autoInjectContext: true,
+  branchSessions: {}
+};
+function getShivaDir(projectPath) {
+  return path.join(projectPath, SHIVA_DIR);
+}
+function getConfigPath(projectPath) {
+  return path.join(getShivaDir(projectPath), CONFIG_FILE);
+}
+function getSessionsDir(projectPath) {
+  return path.join(getShivaDir(projectPath), SESSIONS_DIR);
+}
+function getContextDir(projectPath) {
+  return path.join(getShivaDir(projectPath), CONTEXT_DIR);
+}
+function hasShivaDir(projectPath) {
+  return fs.existsSync(getShivaDir(projectPath));
+}
+function initShivaDir(projectPath) {
+  const shivaDir = getShivaDir(projectPath);
+  const sessionsDir = getSessionsDir(projectPath);
+  const contextDir = getContextDir(projectPath);
+  if (!fs.existsSync(shivaDir)) {
+    fs.mkdirSync(shivaDir, { recursive: true });
+  }
+  if (!fs.existsSync(sessionsDir)) {
+    fs.mkdirSync(sessionsDir, { recursive: true });
+  }
+  if (!fs.existsSync(contextDir)) {
+    fs.mkdirSync(contextDir, { recursive: true });
+  }
+  const configPath = getConfigPath(projectPath);
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
+  }
+}
+function addToGitignore(projectPath) {
+  const gitignorePath = path.join(projectPath, ".gitignore");
+  let content = "";
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, "utf-8");
+    if (content.includes(".shiva") || content.includes("/.shiva")) {
+      return false;
+    }
+  }
+  const newEntry = "\n# SHIVA Code local config\n.shiva/\n";
+  fs.writeFileSync(gitignorePath, content + newEntry, "utf-8");
+  return true;
+}
+function removeFromGitignore(projectPath) {
+  const gitignorePath = path.join(projectPath, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    return false;
+  }
+  let content = fs.readFileSync(gitignorePath, "utf-8");
+  const lines = content.split("\n");
+  const filtered = lines.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed !== ".shiva/" && trimmed !== ".shiva" && trimmed !== "/.shiva/";
+  });
+  const finalLines = filtered.filter((line, i, arr) => {
+    return !(line.includes("# SHIVA Code") && arr[i + 1]?.trim() === "");
+  });
+  const newContent = finalLines.join("\n");
+  if (newContent !== content) {
+    fs.writeFileSync(gitignorePath, newContent, "utf-8");
+    return true;
+  }
+  return false;
+}
+function getProjectConfig(projectPath) {
+  const configPath = getConfigPath(projectPath);
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return { ...DEFAULT_CONFIG, ...config };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveProjectConfig(projectPath, config) {
+  initShivaDir(projectPath);
+  const configPath = getConfigPath(projectPath);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function updateProjectConfig(projectPath, updates) {
+  const current = getProjectConfig(projectPath);
+  const updated = { ...current, ...updates };
+  saveProjectConfig(projectPath, updated);
+  return updated;
+}
+function sanitizeBranchName(branch) {
+  return branch.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function mapBranchToSession(projectPath, branch, sessionId, metadata) {
+  initShivaDir(projectPath);
+  const config = getProjectConfig(projectPath);
+  config.branchSessions[branch] = {
+    branch,
+    sessionId,
+    lastAccessed: (/* @__PURE__ */ new Date()).toISOString(),
+    ...metadata
+  };
+  saveProjectConfig(projectPath, config);
+  const sessionsDir = getSessionsDir(projectPath);
+  const sessionFile = path.join(sessionsDir, `${sanitizeBranchName(branch)}.json`);
+  fs.writeFileSync(
+    sessionFile,
+    JSON.stringify(config.branchSessions[branch], null, 2),
+    "utf-8"
+  );
+}
+function getSessionForBranch(projectPath, branch) {
+  const config = getProjectConfig(projectPath);
+  if (config.branchSessions[branch]) {
+    return config.branchSessions[branch];
+  }
+  const sessionsDir = getSessionsDir(projectPath);
+  const sessionFile = path.join(sessionsDir, `${sanitizeBranchName(branch)}.json`);
+  if (fs.existsSync(sessionFile)) {
+    try {
+      const content = fs.readFileSync(sessionFile, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function getAllBranchSessions(projectPath) {
+  const config = getProjectConfig(projectPath);
+  return config.branchSessions || {};
+}
+function updateBranchSession(projectPath, branch, updates) {
+  const existing = getSessionForBranch(projectPath, branch);
+  if (!existing) {
+    return;
+  }
+  mapBranchToSession(projectPath, branch, existing.sessionId, {
+    ...existing,
+    ...updates,
+    lastAccessed: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function removeBranchSession(projectPath, branch) {
+  const config = getProjectConfig(projectPath);
+  if (config.branchSessions[branch]) {
+    delete config.branchSessions[branch];
+    saveProjectConfig(projectPath, config);
+  }
+  const sessionsDir = getSessionsDir(projectPath);
+  const sessionFile = path.join(sessionsDir, `${sanitizeBranchName(branch)}.json`);
+  if (fs.existsSync(sessionFile)) {
+    fs.unlinkSync(sessionFile);
+  }
+}
+function cacheGitHubContext(projectPath, context) {
+  initShivaDir(projectPath);
+  const contextDir = getContextDir(projectPath);
+  const contextFile = path.join(contextDir, GITHUB_CONTEXT_FILE);
+  fs.writeFileSync(contextFile, context, "utf-8");
+  return contextFile;
+}
+function getCachedGitHubContext(projectPath) {
+  const contextDir = getContextDir(projectPath);
+  const contextFile = path.join(contextDir, GITHUB_CONTEXT_FILE);
+  if (!fs.existsSync(contextFile)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(contextFile, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getContextCacheAge(projectPath) {
+  const contextDir = getContextDir(projectPath);
+  const contextFile = path.join(contextDir, GITHUB_CONTEXT_FILE);
+  if (!fs.existsSync(contextFile)) {
+    return Infinity;
+  }
+  try {
+    const stats = fs.statSync(contextFile);
+    const ageMs = Date.now() - stats.mtimeMs;
+    return Math.floor(ageMs / (1e3 * 60));
+  } catch {
+    return Infinity;
+  }
+}
+function clearContextCache(projectPath) {
+  const contextDir = getContextDir(projectPath);
+  const contextFile = path.join(contextDir, GITHUB_CONTEXT_FILE);
+  if (fs.existsSync(contextFile)) {
+    fs.unlinkSync(contextFile);
+  }
+}
+function removeShivaDir(projectPath) {
+  const shivaDir = getShivaDir(projectPath);
+  if (fs.existsSync(shivaDir)) {
+    fs.rmSync(shivaDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  getShivaDir,
+  hasShivaDir,
+  initShivaDir,
+  addToGitignore,
+  removeFromGitignore,
+  getProjectConfig,
+  saveProjectConfig,
+  updateProjectConfig,
+  mapBranchToSession,
+  getSessionForBranch,
+  getAllBranchSessions,
+  updateBranchSession,
+  removeBranchSession,
+  cacheGitHubContext,
+  getCachedGitHubContext,
+  getContextCacheAge,
+  clearContextCache,
+  removeShivaDir
+};