shiva-code 0.3.0 → 0.4.2

package/dist/{github-R3I7U2DQ.js → api-MT23KCO3.js}

@@ -21,8 +21,9 @@ import {
   parseGitHubUrl,
   runGh,
   runGhRaw
-} from "./chunk-66D4NGIK.js";
-import "./chunk-G2G6UUWM.js";
+} from "./chunk-ZDLLPNCK.js";
+import "./chunk-6RAACMKF.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   findMentionedIssueNumbers,
   formatContextAsMarkdown,

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/{chunk-G2G6UUWM.js → chunk-6RAACMKF.js}

@@ -1,4 +1,4 @@
-// src/services/cache.ts
+// src/services/data/cache.ts
 var CacheService = class _CacheService {
   cache;
   // Default TTLs in milliseconds

package/dist/chunk-PMA6MGQW.js

@@ -0,0 +1,604 @@
+// src/services/project/config.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/types/security.ts
+var SECURITY_PRESETS = {
+  beginner: {
+    skipPermissions: false,
+    approvalStrategy: "manual",
+    dockerIsolation: true,
+    require2FA: false,
+    timeRestrictions: false
+  },
+  standard: {
+    skipPermissions: true,
+    approvalStrategy: "hybrid",
+    dockerIsolation: false,
+    require2FA: false,
+    timeRestrictions: false
+  },
+  strict: {
+    skipPermissions: false,
+    approvalStrategy: "manual",
+    dockerIsolation: true,
+    require2FA: true,
+    timeRestrictions: true
+  }
+};
+var DEFAULT_SESSION_TIME_CONFIG = {
+  enabled: false,
+  allowedHours: { start: "09:00", end: "18:00" },
+  allowedDays: [1, 2, 3, 4, 5],
+  // Monday to Friday
+  timezone: "Europe/Berlin"
+};
+var DEFAULT_SESSION_LIMITS = {
+  maxDurationMinutes: null,
+  maxTokens: null,
+  warningThreshold: 0.8
+};
+var DEFAULT_SESSION_BUDGET = {
+  dailyTokenLimit: null,
+  weeklyTokenLimit: null,
+  monthlyTokenLimit: null,
+  currentUsage: {
+    daily: 0,
+    weekly: 0,
+    monthly: 0,
+    lastReset: {
+      daily: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      weekly: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      monthly: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    }
+  }
+};
+var DEFAULT_PERMISSION_CONFIG = {
+  skipPermissions: "inherit",
+  allowedTools: "all",
+  blockedTools: [],
+  allowedPaths: [],
+  blockedPaths: [".env", "secrets/"]
+};
+var DEFAULT_APPROVAL_CONFIG = {
+  strategy: "hybrid",
+  thresholds: {
+    autoApproveMaxFiles: 5,
+    autoApproveMaxLines: 200,
+    requireApprovalPatterns: ["*.secret"],
+    skipApprovalPatterns: ["*.test.ts"]
+  }
+};
+var DEFAULT_PROJECT_DOCKER_CONFIG = {
+  enabled: "inherit",
+  image: "default",
+  network: "bridge",
+  resources: {
+    cpuLimit: null,
+    memoryLimit: null
+  },
+  mounts: [],
+  environment: {},
+  securityOpts: []
+};
+var DEFAULT_ANALYTICS_CONFIG = {
+  enabled: true,
+  collectTokenUsage: true,
+  collectSessionHistory: true,
+  retentionDays: 90
+};
+var DEFAULT_SECURITY_CONFIG = {
+  tier: "standard",
+  permissions: DEFAULT_PERMISSION_CONFIG,
+  approval: DEFAULT_APPROVAL_CONFIG,
+  require2FA: false
+};
+var DEFAULT_PROJECT_CONFIG_V2 = {
+  version: 2,
+  autoInjectContext: true,
+  branchSessions: {},
+  security: DEFAULT_SECURITY_CONFIG,
+  session: {
+    timeControl: DEFAULT_SESSION_TIME_CONFIG,
+    limits: DEFAULT_SESSION_LIMITS,
+    budget: DEFAULT_SESSION_BUDGET
+  },
+  docker: DEFAULT_PROJECT_DOCKER_CONFIG,
+  analytics: DEFAULT_ANALYTICS_CONFIG
+};
+
+// src/services/project/config.ts
+var SHIVA_DIR = ".shiva";
+var CONFIG_FILE = "config.json";
+var SESSIONS_DIR = "sessions";
+var CONTEXT_DIR = "context";
+var ANALYTICS_DIR = "analytics";
+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 });
+  }
+}
+function getAnalyticsDir(projectPath) {
+  return path.join(getShivaDir(projectPath), ANALYTICS_DIR);
+}
+function migrateToV2(v1Config) {
+  return {
+    ...DEFAULT_PROJECT_CONFIG_V2,
+    version: 2,
+    githubRepo: v1Config.githubRepo,
+    defaultBranch: v1Config.defaultBranch,
+    autoInjectContext: v1Config.autoInjectContext,
+    branchSessions: v1Config.branchSessions
+  };
+}
+function isV2Config(config) {
+  return config.version === 2;
+}
+function getProjectConfigV2(projectPath) {
+  const configPath = path.join(getShivaDir(projectPath), CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_PROJECT_CONFIG_V2 };
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    if (!config.version || config.version === 1) {
+      const v2Config = migrateToV2(config);
+      saveProjectConfigV2(projectPath, v2Config);
+      return v2Config;
+    }
+    return {
+      ...DEFAULT_PROJECT_CONFIG_V2,
+      ...config,
+      security: { ...DEFAULT_SECURITY_CONFIG, ...config.security },
+      session: {
+        timeControl: { ...DEFAULT_SESSION_TIME_CONFIG, ...config.session?.timeControl },
+        limits: { ...DEFAULT_SESSION_LIMITS, ...config.session?.limits },
+        budget: { ...DEFAULT_SESSION_BUDGET, ...config.session?.budget }
+      },
+      docker: { ...DEFAULT_PROJECT_DOCKER_CONFIG, ...config.docker },
+      analytics: { ...DEFAULT_ANALYTICS_CONFIG, ...config.analytics }
+    };
+  } catch {
+    return { ...DEFAULT_PROJECT_CONFIG_V2 };
+  }
+}
+function saveProjectConfigV2(projectPath, config) {
+  initShivaDir(projectPath);
+  const analyticsDir = getAnalyticsDir(projectPath);
+  if (!fs.existsSync(analyticsDir)) {
+    fs.mkdirSync(analyticsDir, { recursive: true });
+  }
+  const configPath = path.join(getShivaDir(projectPath), CONFIG_FILE);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function updateProjectConfigV2(projectPath, updates) {
+  const current = getProjectConfigV2(projectPath);
+  const updated = { ...current, ...updates };
+  saveProjectConfigV2(projectPath, updated);
+  return updated;
+}
+function getSessionConfig(projectPath) {
+  const config = getProjectConfigV2(projectPath);
+  return config.session;
+}
+function updateTimeControl(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.session.timeControl,
+    ...updates
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    session: {
+      ...config.session,
+      timeControl: updated
+    }
+  });
+  return updated;
+}
+function updateSessionLimits(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.session.limits,
+    ...updates
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    session: {
+      ...config.session,
+      limits: updated
+    }
+  });
+  return updated;
+}
+function updateSessionBudget(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.session.budget,
+    ...updates,
+    currentUsage: {
+      ...config.session.budget.currentUsage,
+      ...updates.currentUsage,
+      lastReset: {
+        ...config.session.budget.currentUsage.lastReset,
+        ...updates.currentUsage?.lastReset
+      }
+    }
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    session: {
+      ...config.session,
+      budget: updated
+    }
+  });
+  return updated;
+}
+function resetSessionBudget(projectPath) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return updateSessionBudget(projectPath, {
+    currentUsage: {
+      daily: 0,
+      weekly: 0,
+      monthly: 0,
+      lastReset: {
+        daily: today,
+        weekly: today,
+        monthly: today
+      }
+    }
+  });
+}
+function getSecurityConfig(projectPath) {
+  const config = getProjectConfigV2(projectPath);
+  return config.security;
+}
+function updateSecurityConfig(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.security,
+    ...updates,
+    permissions: {
+      ...config.security.permissions,
+      ...updates.permissions
+    },
+    approval: {
+      ...config.security.approval,
+      ...updates.approval,
+      thresholds: {
+        ...config.security.approval.thresholds,
+        ...updates.approval?.thresholds
+      }
+    }
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    security: updated
+  });
+  return updated;
+}
+function updatePermissions(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.security.permissions,
+    ...updates
+  };
+  return updateSecurityConfig(projectPath, { permissions: updated }).permissions;
+}
+function updateApproval(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.security.approval,
+    ...updates,
+    thresholds: {
+      ...config.security.approval.thresholds,
+      ...updates.thresholds
+    }
+  };
+  return updateSecurityConfig(projectPath, { approval: updated }).approval;
+}
+function getProjectDockerConfig(projectPath) {
+  const config = getProjectConfigV2(projectPath);
+  return config.docker;
+}
+function updateProjectDockerConfig(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.docker,
+    ...updates,
+    resources: {
+      ...config.docker.resources,
+      ...updates.resources
+    }
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    docker: updated
+  });
+  return updated;
+}
+function addDockerMount(projectPath, host, container, mode = "rw") {
+  const config = getProjectConfigV2(projectPath);
+  const mounts = [...config.docker.mounts];
+  const existingIndex = mounts.findIndex((m) => m.container === container);
+  if (existingIndex >= 0) {
+    mounts.splice(existingIndex, 1);
+  }
+  mounts.push({ host, container, mode });
+  return updateProjectDockerConfig(projectPath, { mounts });
+}
+function removeDockerMount(projectPath, container) {
+  const config = getProjectConfigV2(projectPath);
+  const mounts = config.docker.mounts.filter((m) => m.container !== container);
+  return updateProjectDockerConfig(projectPath, { mounts });
+}
+function getAnalyticsConfig(projectPath) {
+  const config = getProjectConfigV2(projectPath);
+  return config.analytics;
+}
+function updateAnalyticsConfig(projectPath, updates) {
+  const config = getProjectConfigV2(projectPath);
+  const updated = {
+    ...config.analytics,
+    ...updates
+  };
+  saveProjectConfigV2(projectPath, {
+    ...config,
+    analytics: updated
+  });
+  return updated;
+}
+function getAnalyticsFilePath(projectPath, yearMonth) {
+  const month = yearMonth || (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+  return path.join(getAnalyticsDir(projectPath), `${month}.json`);
+}
+function getAnalyticsSummaryPath(projectPath) {
+  return path.join(getAnalyticsDir(projectPath), "summary.json");
+}
+
+export {
+  SECURITY_PRESETS,
+  getShivaDir,
+  hasShivaDir,
+  initShivaDir,
+  addToGitignore,
+  removeFromGitignore,
+  getProjectConfig,
+  saveProjectConfig,
+  updateProjectConfig,
+  mapBranchToSession,
+  getSessionForBranch,
+  getAllBranchSessions,
+  updateBranchSession,
+  removeBranchSession,
+  cacheGitHubContext,
+  getCachedGitHubContext,
+  getContextCacheAge,
+  clearContextCache,
+  removeShivaDir,
+  isV2Config,
+  getProjectConfigV2,
+  saveProjectConfigV2,
+  updateProjectConfigV2,
+  getSessionConfig,
+  updateTimeControl,
+  updateSessionLimits,
+  updateSessionBudget,
+  resetSessionBudget,
+  getSecurityConfig,
+  updateSecurityConfig,
+  updatePermissions,
+  updateApproval,
+  getProjectDockerConfig,
+  updateProjectDockerConfig,
+  addDockerMount,
+  removeDockerMount,
+  getAnalyticsConfig,
+  updateAnalyticsConfig,
+  getAnalyticsFilePath,
+  getAnalyticsSummaryPath
+};

package/dist/{chunk-MDMZWOX7.js → chunk-TI6Y3VT4.js}

@@ -1,8 +1,8 @@
 import {
   cache
-} from "./chunk-G2G6UUWM.js";
+} from "./chunk-6RAACMKF.js";
 
-// src/services/session-manager.ts
+// src/services/session/manager.ts
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";

package/dist/{chunk-GHAT2D55.js → chunk-TQ6O4QB6.js}

@@ -1,9 +1,9 @@
 import {
   findProject,
   getProjectName
-} from "./chunk-MDMZWOX7.js";
+} from "./chunk-TI6Y3VT4.js";
 
-// src/services/package-manager.ts
+// src/services/data/package-manager.ts
 import Conf from "conf";
 import * as fs from "fs";
 import * as path from "path";

package/dist/{chunk-66D4NGIK.js → chunk-ZDLLPNCK.js}

@@ -1,8 +1,8 @@
 import {
   cache
-} from "./chunk-G2G6UUWM.js";
+} from "./chunk-6RAACMKF.js";
 
-// src/services/github.ts
+// src/services/github/api.ts
 import { execSync, spawnSync } from "child_process";
 function isGhInstalled() {
   try {