octocode-shared 1.0.0

package/dist/platform/platform.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Platform Detection & Utilities
+ *
+ * Cross-platform utilities for octocode packages.
+ */
+/** Check if running on Windows */
+export declare const isWindows: boolean;
+/** Check if running on macOS */
+export declare const isMac: boolean;
+/** Check if running on Linux */
+export declare const isLinux: boolean;
+/** User's home directory */
+export declare const HOME: string;
+/**
+ * Get the AppData path on Windows, HOME on other platforms
+ */
+export declare function getAppDataPath(): string;
+/**
+ * Get the local AppData path on Windows, HOME on other platforms
+ */
+export declare function getLocalAppDataPath(): string;
+/**
+ * Get platform name for display
+ */
+export declare function getPlatformName(): string;
+/**
+ * Get architecture for display
+ */
+export declare function getArchitecture(): string;
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/platform/platform.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,kCAAkC;AAClC,eAAO,MAAM,SAAS,EAAE,OAAmC,CAAC;AAE5D,gCAAgC;AAChC,eAAO,MAAM,KAAK,EAAE,OAAoC,CAAC;AAEzD,gCAAgC;AAChC,eAAO,MAAM,OAAO,EAAE,OAAmC,CAAC;AAE1D,4BAA4B;AAC5B,eAAO,MAAM,IAAI,EAAE,MAAqB,CAAC;AAEzC;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAKvC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAK5C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/platform-1V_81nPi.js

@@ -0,0 +1,37 @@
+import os from "node:os";
+import path from "node:path";
+const isWindows = os.platform() === "win32";
+const isMac = os.platform() === "darwin";
+const isLinux = os.platform() === "linux";
+const HOME = os.homedir();
+function getAppDataPath() {
+  if (isWindows) {
+    return process.env.APPDATA || path.join(HOME, "AppData", "Roaming");
+  }
+  return HOME;
+}
+function getLocalAppDataPath() {
+  if (isWindows) {
+    return process.env.LOCALAPPDATA || path.join(HOME, "AppData", "Local");
+  }
+  return HOME;
+}
+function getPlatformName() {
+  if (isMac) return "macOS";
+  if (isWindows) return "Windows";
+  if (isLinux) return "Linux";
+  return os.platform();
+}
+function getArchitecture() {
+  return os.arch();
+}
+export {
+  HOME as H,
+  isMac as a,
+  isLinux as b,
+  getLocalAppDataPath as c,
+  getPlatformName as d,
+  getArchitecture as e,
+  getAppDataPath as g,
+  isWindows as i
+};

package/dist/session/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Session Module
+ *
+ * Persistent session management for Octocode packages.
+ * Stores session data in ~/.octocode/session.json with cross-platform support.
+ */
+export type { PersistedSession, SessionStats, SessionUpdateResult, SessionOptions, } from './types.js';
+export { SESSION_FILE } from './storage.js';
+export { readSession, writeSession, getOrCreateSession, getSessionId, deleteSession, flushSession, flushSessionSync, } from './storage.js';
+export { updateSessionStats, incrementToolCalls, incrementPromptCalls, incrementErrors, incrementRateLimits, resetSessionStats, } from './storage.js';
+export { _resetSessionState } from './storage.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,OAAO,EACL,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC"}

package/dist/session/index.js

@@ -0,0 +1,18 @@
+import { S, _, d, f, b, g, a, e, c, h, i, r, j, u, w } from "../storage-D-QEqQEn.js";
+export {
+  S as SESSION_FILE,
+  _ as _resetSessionState,
+  d as deleteSession,
+  f as flushSession,
+  b as flushSessionSync,
+  g as getOrCreateSession,
+  a as getSessionId,
+  e as incrementErrors,
+  c as incrementPromptCalls,
+  h as incrementRateLimits,
+  i as incrementToolCalls,
+  r as readSession,
+  j as resetSessionStats,
+  u as updateSessionStats,
+  w as writeSession
+};

package/dist/session/storage.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Session Storage
+ *
+ * Persistent session storage in ~/.octocode/session.json
+ * Cross-platform support for Windows, Linux, and macOS.
+ *
+ * Uses batch saving to reduce disk I/O - changes are buffered in memory
+ * and flushed to disk every 60 seconds or on process exit.
+ */
+import type { PersistedSession, SessionStats, SessionUpdateResult, SessionOptions } from './types.js';
+export declare const SESSION_FILE: string;
+/**
+ * Read session (from cache or disk)
+ * @returns The persisted session or null if not found/invalid
+ */
+export declare function readSession(): PersistedSession | null;
+/**
+ * Write session (to cache, batched to disk)
+ * Changes are buffered and flushed every 60 seconds or on process exit.
+ */
+export declare function writeSession(session: PersistedSession): void;
+/**
+ * Flush session to disk immediately
+ * Use this when you need to ensure data is persisted (e.g., before critical operations)
+ */
+export declare function flushSession(): void;
+/**
+ * Flush session to disk synchronously (for exit handlers)
+ */
+export declare function flushSessionSync(): void;
+/**
+ * Get or create a session
+ * - If session exists and is valid, update lastActiveAt and return it
+ * - If session doesn't exist or is invalid, create a new one
+ *
+ * @param options - Session options (forceNew to create fresh session)
+ * @returns The persisted session
+ */
+export declare function getOrCreateSession(options?: SessionOptions): PersistedSession;
+/**
+ * Get the current session ID without modifying the session
+ * @returns The session ID or null if no session exists
+ */
+export declare function getSessionId(): string | null;
+/**
+ * Update session statistics
+ * Increments the specified stat counters (batched to disk)
+ *
+ * @param updates - Partial stats to increment
+ * @returns Result with success status and updated session
+ */
+export declare function updateSessionStats(updates: Partial<SessionStats>): SessionUpdateResult;
+/**
+ * Increment tool call counter (batched)
+ */
+export declare function incrementToolCalls(count?: number): SessionUpdateResult;
+/**
+ * Increment prompt call counter (batched)
+ */
+export declare function incrementPromptCalls(count?: number): SessionUpdateResult;
+/**
+ * Increment error counter (batched)
+ */
+export declare function incrementErrors(count?: number): SessionUpdateResult;
+/**
+ * Increment rate limit counter (batched)
+ */
+export declare function incrementRateLimits(count?: number): SessionUpdateResult;
+/**
+ * Reset session statistics to zero
+ */
+export declare function resetSessionStats(): SessionUpdateResult;
+/**
+ * Delete the current session (for testing or cleanup)
+ * Also cleans up exit handlers to avoid listener warnings in tests
+ * @returns true if session was deleted, false if it didn't exist
+ */
+export declare function deleteSession(): boolean;
+/**
+ * Reset internal state (for testing)
+ * This properly cleans up all listeners to avoid MaxListenersExceededWarning
+ * @internal
+ */
+export declare function _resetSessionState(): void;
+//# sourceMappingURL=storage.d.ts.map

package/dist/session/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/session/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AAGpB,eAAO,MAAM,YAAY,QAAqC,CAAC;AAmL/D;;;GAGG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,GAAG,IAAI,CAYrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAO5D;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAKnC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,gBAAgB,CA+B7E;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,IAAI,CAG5C;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAC7B,mBAAmB,CAwBrB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,GAAE,MAAU,GAAG,mBAAmB,CAEzE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,GAAE,MAAU,GAAG,mBAAmB,CAE3E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,GAAE,MAAU,GAAG,mBAAmB,CAEtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,MAAU,GAAG,mBAAmB,CAE1E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,mBAAmB,CAevD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAmBvC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC"}

package/dist/session/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Session Types
+ *
+ * Types for session persistence across octocode packages.
+ */
+/**
+ * Session statistics tracking
+ */
+export interface SessionStats {
+    toolCalls: number;
+    promptCalls: number;
+    errors: number;
+    rateLimits: number;
+}
+/**
+ * Persisted session data stored in ~/.octocode/session.json
+ */
+export interface PersistedSession {
+    /** Schema version for future migrations */
+    version: 1;
+    /** Unique session identifier (UUID) */
+    sessionId: string;
+    /** When the session was first created */
+    createdAt: string;
+    /** Last time the session was active (updated on init) */
+    lastActiveAt: string;
+    /** Cumulative session statistics */
+    stats: SessionStats;
+}
+/**
+ * Result from updating session stats
+ */
+export interface SessionUpdateResult {
+    success: boolean;
+    session: PersistedSession | null;
+}
+/**
+ * Options for creating/loading a session
+ */
+export interface SessionOptions {
+    /** Force create a new session even if one exists */
+    forceNew?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/session/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/session/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2CAA2C;IAC3C,OAAO,EAAE,CAAC,CAAC;IACX,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,oCAAoC;IACpC,KAAK,EAAE,YAAY,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/storage-D-QEqQEn.js

@@ -0,0 +1,244 @@
+import { existsSync, unlinkSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { O as OCTOCODE_DIR, A as ensureOctocodeDir } from "./storage-DuH3rTiu.js";
+const SESSION_FILE = join(OCTOCODE_DIR, "session.json");
+const CURRENT_VERSION = 1;
+const FLUSH_INTERVAL_MS = 6e4;
+let cachedSession = null;
+let isDirty = false;
+let flushTimer = null;
+let exitHandlersRegistered = false;
+let exitListener = null;
+let sigintListener = null;
+let sigtermListener = null;
+function registerExitHandlers() {
+  if (exitHandlersRegistered) return;
+  exitHandlersRegistered = true;
+  exitListener = () => {
+    flushSessionSync();
+  };
+  sigintListener = () => {
+    flushSessionSync();
+  };
+  sigtermListener = () => {
+    flushSessionSync();
+  };
+  process.on("exit", exitListener);
+  process.once("SIGINT", sigintListener);
+  process.once("SIGTERM", sigtermListener);
+}
+function unregisterExitHandlers() {
+  if (exitListener) {
+    process.removeListener("exit", exitListener);
+    exitListener = null;
+  }
+  if (sigintListener) {
+    process.removeListener("SIGINT", sigintListener);
+    sigintListener = null;
+  }
+  if (sigtermListener) {
+    process.removeListener("SIGTERM", sigtermListener);
+    sigtermListener = null;
+  }
+  exitHandlersRegistered = false;
+}
+function startFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(() => {
+    if (isDirty && cachedSession) {
+      writeSessionToDisk(cachedSession);
+      isDirty = false;
+    }
+  }, FLUSH_INTERVAL_MS);
+  flushTimer.unref();
+}
+function stopFlushTimer() {
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+}
+function writeSessionToDisk(session) {
+  ensureOctocodeDir();
+  const tempFile = `${SESSION_FILE}.tmp`;
+  writeFileSync(tempFile, JSON.stringify(session, null, 2), {
+    mode: 384
+  });
+  renameSync(tempFile, SESSION_FILE);
+}
+function readSessionFromDisk() {
+  if (!existsSync(SESSION_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(SESSION_FILE, "utf8");
+    const session = JSON.parse(content);
+    if (session.version !== CURRENT_VERSION) {
+      return null;
+    }
+    if (!session.sessionId || !session.createdAt) {
+      return null;
+    }
+    return session;
+  } catch {
+    return null;
+  }
+}
+function createDefaultStats() {
+  return {
+    toolCalls: 0,
+    promptCalls: 0,
+    errors: 0,
+    rateLimits: 0
+  };
+}
+function createNewSession() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: CURRENT_VERSION,
+    sessionId: randomUUID(),
+    createdAt: now,
+    lastActiveAt: now,
+    stats: createDefaultStats()
+  };
+}
+function readSession() {
+  if (cachedSession) {
+    return cachedSession;
+  }
+  const session = readSessionFromDisk();
+  if (session) {
+    cachedSession = session;
+  }
+  return session;
+}
+function writeSession(session) {
+  cachedSession = session;
+  isDirty = true;
+  registerExitHandlers();
+  startFlushTimer();
+}
+function flushSession() {
+  if (isDirty && cachedSession) {
+    writeSessionToDisk(cachedSession);
+    isDirty = false;
+  }
+}
+function flushSessionSync() {
+  if (isDirty && cachedSession) {
+    try {
+      writeSessionToDisk(cachedSession);
+      isDirty = false;
+    } catch {
+    }
+  }
+}
+function getOrCreateSession(options) {
+  if (options?.forceNew) {
+    const newSession2 = createNewSession();
+    writeSession(newSession2);
+    flushSession();
+    return newSession2;
+  }
+  const existingSession = readSession();
+  if (existingSession) {
+    const updatedSession = {
+      ...existingSession,
+      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeSession(updatedSession);
+    flushSession();
+    return updatedSession;
+  }
+  const newSession = createNewSession();
+  writeSession(newSession);
+  flushSession();
+  return newSession;
+}
+function getSessionId() {
+  const session = readSession();
+  return session?.sessionId ?? null;
+}
+function updateSessionStats(updates) {
+  const session = readSession();
+  if (!session) {
+    return { success: false, session: null };
+  }
+  const updatedStats = {
+    toolCalls: session.stats.toolCalls + (updates.toolCalls ?? 0),
+    promptCalls: session.stats.promptCalls + (updates.promptCalls ?? 0),
+    errors: session.stats.errors + (updates.errors ?? 0),
+    rateLimits: session.stats.rateLimits + (updates.rateLimits ?? 0)
+  };
+  const updatedSession = {
+    ...session,
+    lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: updatedStats
+  };
+  writeSession(updatedSession);
+  return { success: true, session: updatedSession };
+}
+function incrementToolCalls(count = 1) {
+  return updateSessionStats({ toolCalls: count });
+}
+function incrementPromptCalls(count = 1) {
+  return updateSessionStats({ promptCalls: count });
+}
+function incrementErrors(count = 1) {
+  return updateSessionStats({ errors: count });
+}
+function incrementRateLimits(count = 1) {
+  return updateSessionStats({ rateLimits: count });
+}
+function resetSessionStats() {
+  const session = readSession();
+  if (!session) {
+    return { success: false, session: null };
+  }
+  const updatedSession = {
+    ...session,
+    lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: createDefaultStats()
+  };
+  writeSession(updatedSession);
+  return { success: true, session: updatedSession };
+}
+function deleteSession() {
+  cachedSession = null;
+  isDirty = false;
+  stopFlushTimer();
+  unregisterExitHandlers();
+  if (!existsSync(SESSION_FILE)) {
+    return false;
+  }
+  try {
+    unlinkSync(SESSION_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _resetSessionState() {
+  cachedSession = null;
+  isDirty = false;
+  stopFlushTimer();
+  unregisterExitHandlers();
+}
+export {
+  SESSION_FILE as S,
+  _resetSessionState as _,
+  getSessionId as a,
+  flushSessionSync as b,
+  incrementPromptCalls as c,
+  deleteSession as d,
+  incrementErrors as e,
+  flushSession as f,
+  getOrCreateSession as g,
+  incrementRateLimits as h,
+  incrementToolCalls as i,
+  resetSessionStats as j,
+  readSession as r,
+  updateSessionStats as u,
+  writeSession as w
+};