@snapback/cli 1.1.14 → 1.1.15

package/dist/{chunk-Q5XZ3DCB.js → chunk-DPWFZNMY.js}

@@ -1,11 +1,93 @@
-#!/usr/bin/env node
-import { __name } from './chunk-BW7RALUZ.js';
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { __name } from './chunk-7ADPL4Q3.js';
 import { mkdir, writeFile, access, constants, readFile, appendFile, stat } from 'fs/promises';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
+import { z } from 'zod';
 
+process.env.SNAPBACK_CLI='true';
 var SNAPBACK_DIR = ".snapback";
 var GLOBAL_SNAPBACK_DIR = ".snapback";
+var WorkspaceConfigSchema = z.object({
+  workspaceId: z.string().optional(),
+  tier: z.enum([
+    "free",
+    "pro"
+  ]).optional(),
+  protectionLevel: z.enum([
+    "standard",
+    "strict"
+  ]).optional(),
+  syncEnabled: z.boolean().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var WorkspaceVitalsSchema = z.object({
+  framework: z.string().optional(),
+  frameworkConfidence: z.number().optional(),
+  packageManager: z.enum([
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun"
+  ]).optional(),
+  typescript: z.object({
+    enabled: z.boolean(),
+    strict: z.boolean().optional(),
+    version: z.string().optional()
+  }).optional(),
+  criticalFiles: z.array(z.string()).optional(),
+  detectedAt: z.string()
+});
+var ProtectedFileSchema = z.object({
+  pattern: z.string(),
+  addedAt: z.string(),
+  reason: z.string().optional()
+});
+var SessionStateSchema = z.object({
+  id: z.string(),
+  task: z.string().optional(),
+  startedAt: z.string(),
+  snapshotCount: z.number(),
+  filesModified: z.number().optional()
+});
+var LearningEntrySchema = z.object({
+  id: z.string(),
+  type: z.enum([
+    "pattern",
+    "pitfall",
+    "efficiency",
+    "discovery",
+    "workflow"
+  ]),
+  trigger: z.string(),
+  action: z.string(),
+  source: z.string(),
+  createdAt: z.string()
+});
+var ViolationEntrySchema = z.object({
+  type: z.string(),
+  file: z.string(),
+  message: z.string(),
+  count: z.number().optional(),
+  date: z.string(),
+  prevention: z.string().optional()
+});
+var GlobalCredentialsSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string().optional(),
+  email: z.string(),
+  tier: z.enum([
+    "free",
+    "pro"
+  ]),
+  expiresAt: z.string().optional()
+});
+var GlobalConfigSchema = z.object({
+  apiUrl: z.string().optional(),
+  defaultWorkspace: z.string().optional(),
+  analytics: z.boolean().optional()
+});
 function getGlobalDir() {
   return join(homedir(), GLOBAL_SNAPBACK_DIR);
 }
@@ -155,7 +237,12 @@ async function deleteGlobalJson(relativePath) {
 }
 __name(deleteGlobalJson, "deleteGlobalJson");
 async function getWorkspaceConfig(workspaceRoot) {
-  return readSnapbackJson("config.json", workspaceRoot);
+  const data = await readSnapbackJson("config.json", workspaceRoot);
+  if (!data) {
+    return null;
+  }
+  const result = WorkspaceConfigSchema.safeParse(data);
+  return result.success ? result.data : null;
 }
 __name(getWorkspaceConfig, "getWorkspaceConfig");
 async function saveWorkspaceConfig(config, workspaceRoot) {
@@ -163,7 +250,12 @@ async function saveWorkspaceConfig(config, workspaceRoot) {
 }
 __name(saveWorkspaceConfig, "saveWorkspaceConfig");
 async function getWorkspaceVitals(workspaceRoot) {
-  return readSnapbackJson("vitals.json", workspaceRoot);
+  const data = await readSnapbackJson("vitals.json", workspaceRoot);
+  if (!data) {
+    return null;
+  }
+  const result = WorkspaceVitalsSchema.safeParse(data);
+  return result.success ? result.data : null;
 }
 __name(getWorkspaceVitals, "getWorkspaceVitals");
 async function saveWorkspaceVitals(vitals, workspaceRoot) {
@@ -171,7 +263,12 @@ async function saveWorkspaceVitals(vitals, workspaceRoot) {
 }
 __name(saveWorkspaceVitals, "saveWorkspaceVitals");
 async function getProtectedFiles(workspaceRoot) {
-  return await readSnapbackJson("protected.json", workspaceRoot) ?? [];
+  const data = await readSnapbackJson("protected.json", workspaceRoot);
+  if (!data) {
+    return [];
+  }
+  const result = z.array(ProtectedFileSchema).safeParse(data);
+  return result.success ? result.data : [];
 }
 __name(getProtectedFiles, "getProtectedFiles");
 async function saveProtectedFiles(files, workspaceRoot) {
@@ -179,7 +276,12 @@ async function saveProtectedFiles(files, workspaceRoot) {
 }
 __name(saveProtectedFiles, "saveProtectedFiles");
 async function getCurrentSession(workspaceRoot) {
-  return readSnapbackJson("session/current.json", workspaceRoot);
+  const data = await readSnapbackJson("session/current.json", workspaceRoot);
+  if (!data) {
+    return null;
+  }
+  const result = SessionStateSchema.safeParse(data);
+  return result.success ? result.data : null;
 }
 __name(getCurrentSession, "getCurrentSession");
 async function saveCurrentSession(session, workspaceRoot) {
@@ -200,7 +302,8 @@ async function recordLearning(learning, workspaceRoot) {
 }
 __name(recordLearning, "recordLearning");
 async function getLearnings(workspaceRoot) {
-  return loadSnapbackJsonl("learnings/user-learnings.jsonl", workspaceRoot);
+  const data = await loadSnapbackJsonl("learnings/user-learnings.jsonl", workspaceRoot);
+  return data.filter((item) => LearningEntrySchema.safeParse(item).success);
 }
 __name(getLearnings, "getLearnings");
 async function recordViolation(violation, workspaceRoot) {
@@ -208,12 +311,13 @@ async function recordViolation(violation, workspaceRoot) {
 }
 __name(recordViolation, "recordViolation");
 async function getViolations(workspaceRoot) {
-  return loadSnapbackJsonl("patterns/violations.jsonl", workspaceRoot);
+  const data = await loadSnapbackJsonl("patterns/violations.jsonl", workspaceRoot);
+  return data.filter((item) => ViolationEntrySchema.safeParse(item).success);
 }
 __name(getViolations, "getViolations");
 async function getCredentials() {
   try {
-    const { getCredentialsSecure } = await import('./secure-credentials-A4QHHOE2.js');
+    const { getCredentialsSecure } = await import('./secure-credentials-UEPG7GWW.js');
     return await getCredentialsSecure();
   } catch {
     return readGlobalJson("credentials.json");
@@ -222,7 +326,7 @@ async function getCredentials() {
 __name(getCredentials, "getCredentials");
 async function saveCredentials(credentials) {
   try {
-    const { saveCredentialsSecure } = await import('./secure-credentials-A4QHHOE2.js');
+    const { saveCredentialsSecure } = await import('./secure-credentials-UEPG7GWW.js');
     return await saveCredentialsSecure(credentials);
   } catch {
     await createGlobalDirectory();
@@ -232,7 +336,7 @@ async function saveCredentials(credentials) {
 __name(saveCredentials, "saveCredentials");
 async function clearCredentials() {
   try {
-    const { clearCredentialsSecure } = await import('./secure-credentials-A4QHHOE2.js');
+    const { clearCredentialsSecure } = await import('./secure-credentials-UEPG7GWW.js');
     return await clearCredentialsSecure();
   } catch {
     await deleteGlobalJson("credentials.json");
@@ -240,7 +344,12 @@ async function clearCredentials() {
 }
 __name(clearCredentials, "clearCredentials");
 async function getGlobalConfig() {
-  return readGlobalJson("config.json");
+  const data = await readGlobalJson("config.json");
+  if (!data) {
+    return null;
+  }
+  const result = GlobalConfigSchema.safeParse(data);
+  return result.success ? result.data : null;
 }
 __name(getGlobalConfig, "getGlobalConfig");
 async function saveGlobalConfig(config) {
@@ -295,6 +404,4 @@ async function getStats(path) {
 }
 __name(getStats, "getStats");
 
-export { appendSnapbackJsonl, clearCredentials, createGlobalDirectory, createSnapbackDirectory, deleteGlobalJson, endCurrentSession, findWorkspaceRoot, getCredentials, getCurrentSession, getGlobalConfig, getGlobalDir, getGlobalPath, getLearnings, getProtectedFiles, getStats, getViolations, getWorkspaceConfig, getWorkspaceDir, getWorkspacePath, getWorkspaceVitals, isLoggedIn, isSnapbackInitialized, loadSnapbackJsonl, pathExists, readGlobalJson, readSnapbackJson, recordLearning, recordViolation, saveCredentials, saveCurrentSession, saveGlobalConfig, saveProtectedFiles, saveWorkspaceConfig, saveWorkspaceVitals, writeGlobalJson, writeSnapbackJson };
-//# sourceMappingURL=chunk-Q5XZ3DCB.js.map
-//# sourceMappingURL=chunk-Q5XZ3DCB.js.map
+export { GlobalConfigSchema, GlobalCredentialsSchema, LearningEntrySchema, ProtectedFileSchema, SessionStateSchema, ViolationEntrySchema, WorkspaceConfigSchema, WorkspaceVitalsSchema, appendSnapbackJsonl, clearCredentials, createGlobalDirectory, createSnapbackDirectory, deleteGlobalJson, endCurrentSession, findWorkspaceRoot, getCredentials, getCurrentSession, getGlobalConfig, getGlobalDir, getGlobalPath, getLearnings, getProtectedFiles, getStats, getViolations, getWorkspaceConfig, getWorkspaceDir, getWorkspacePath, getWorkspaceVitals, isLoggedIn, isSnapbackInitialized, loadSnapbackJsonl, pathExists, readGlobalJson, readSnapbackJson, recordLearning, recordViolation, saveCredentials, saveCurrentSession, saveGlobalConfig, saveProtectedFiles, saveWorkspaceConfig, saveWorkspaceVitals, writeGlobalJson, writeSnapbackJson };

package/dist/chunk-GQ73B37K.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { createLogger, LogLevel } from './chunk-WS36HDEU.js';
+import { __name } from './chunk-7ADPL4Q3.js';
+import { createClient } from 'redis';
+
+process.env.SNAPBACK_CLI='true';
+createLogger({
+  name: "redis-factory",
+  level: LogLevel.INFO
+});
+function isSocketTimeoutError(cause) {
+  if (!cause) return false;
+  return cause?.name === "SocketTimeoutError" || cause?.message?.includes("socket timeout");
+}
+__name(isSocketTimeoutError, "isSocketTimeoutError");
+
+// ../../packages/platform/dist/cache/redis-metrics.js
+var LATENCY_THRESHOLDS = {
+  /** Under 100ms is healthy */
+  healthy: 100,
+  /** Under 500ms is degraded */
+  degraded: 500
+};
+var RedisMetricsCollector = class {
+  static {
+    __name(this, "RedisMetricsCollector");
+  }
+  reconnectAttempts = 0;
+  lastSuccessAt = null;
+  lastErrorAt = null;
+  lastError = null;
+  keyPrefix;
+  constructor(keyPrefix = "") {
+    this.keyPrefix = keyPrefix;
+  }
+  /**
+   * Record a successful operation
+   */
+  recordSuccess() {
+    this.lastSuccessAt = Date.now();
+  }
+  /**
+   * Record an error
+   */
+  recordError(error) {
+    this.lastErrorAt = Date.now();
+    this.lastError = error.message;
+  }
+  /**
+   * Record a reconnection attempt
+   */
+  recordReconnect() {
+    this.reconnectAttempts++;
+  }
+  /**
+   * Reset reconnection counter (after successful connection)
+   */
+  resetReconnectCount() {
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Measure Redis latency using PING command
+   */
+  async measureLatency(client) {
+    if (!client || !client.isReady) {
+      return null;
+    }
+    try {
+      const start = Date.now();
+      await client.ping();
+      const latency = Date.now() - start;
+      this.recordSuccess();
+      return latency;
+    } catch (error) {
+      this.recordError(error);
+      return null;
+    }
+  }
+  /**
+   * Collect comprehensive metrics
+   */
+  async collect(client) {
+    const isConnected = client?.isReady ?? false;
+    const isOpen = client?.isOpen ?? false;
+    const latency = await this.measureLatency(client);
+    let status;
+    let message;
+    if (!isConnected) {
+      status = "unhealthy";
+      message = "Redis client not connected";
+    } else if (latency === null) {
+      status = "unhealthy";
+      message = "Redis PING failed";
+    } else if (latency < LATENCY_THRESHOLDS.healthy) {
+      status = "healthy";
+      message = `Redis latency: ${latency}ms`;
+    } else if (latency < LATENCY_THRESHOLDS.degraded) {
+      status = "degraded";
+      message = `Redis latency elevated: ${latency}ms`;
+    } else {
+      status = "unhealthy";
+      message = `Redis latency too high: ${latency}ms`;
+    }
+    return {
+      isConnected,
+      isOpen,
+      latency,
+      status,
+      message,
+      lastSuccessAt: this.lastSuccessAt,
+      lastErrorAt: this.lastErrorAt,
+      lastError: this.lastError,
+      reconnectAttempts: this.reconnectAttempts,
+      keyPrefix: this.keyPrefix
+    };
+  }
+  /**
+   * Get current reconnection attempt count
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+};
+var metricsCollectors = /* @__PURE__ */ new Map();
+function getMetricsCollector(keyPrefix = "") {
+  let collector = metricsCollectors.get(keyPrefix);
+  if (!collector) {
+    collector = new RedisMetricsCollector(keyPrefix);
+    metricsCollectors.set(keyPrefix, collector);
+  }
+  return collector;
+}
+__name(getMetricsCollector, "getMetricsCollector");
+
+// ../../packages/platform/dist/cache/redis-client.js
+var logger2 = createLogger({
+  name: "redis-client",
+  level: LogLevel.INFO
+});
+var KEY_PREFIX = "cache:";
+var redisClient = null;
+var redisAvailable = false;
+var initializationPromise = null;
+var metricsCollector = getMetricsCollector(KEY_PREFIX);
+async function initializeRedis() {
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = (async () => {
+    const redisUrl = process.env.REDIS_URL;
+    if (!redisUrl) {
+      logger2.warn("REDIS_URL not configured - using in-memory fallback for caching");
+      return;
+    }
+    try {
+      redisClient = createClient({
+        url: redisUrl,
+        socket: {
+          // Connection timeout - how long to wait for initial connection
+          connectTimeout: 1e4,
+          // TCP keepalive - prevents silent connection drops
+          keepAlive: 5e3,
+          // Reconnection strategy with exponential backoff + jitter
+          reconnectStrategy: /* @__PURE__ */ __name((retries, cause) => {
+            if (isSocketTimeoutError(cause)) {
+              logger2.warn("Redis socket timeout - not reconnecting", {
+                cause: cause?.message
+              });
+              return false;
+            }
+            if (retries > 20) {
+              logger2.error("Redis max retries exceeded", {
+                retries,
+                cause: cause?.message
+              });
+              return new Error("Redis connection failed");
+            }
+            const baseDelay = Math.min(2 ** retries * 100, 3e4);
+            const jitter = Math.floor(Math.random() * 200);
+            return baseDelay + jitter;
+          }, "reconnectStrategy")
+        },
+        // Application-level ping to keep connection alive
+        pingInterval: 6e4
+      });
+      redisClient.on("error", (err) => {
+        if (err.message.includes("ECONNRESET") || err.message.includes("ECONNREFUSED")) {
+          logger2.debug("Redis connection error (will reconnect)", {
+            error: err.message
+          });
+        } else {
+          logger2.warn("Redis client error", {
+            error: err.message
+          });
+        }
+        redisAvailable = false;
+        metricsCollector.recordError(err);
+      });
+      redisClient.on("connect", () => {
+        redisAvailable = true;
+        metricsCollector.resetReconnectCount();
+        if (process.env.NODE_ENV !== "production") {
+          logger2.info("Redis connected for platform caching");
+        }
+      });
+      redisClient.on("ready", () => {
+        redisAvailable = true;
+        logger2.debug("Redis client ready for platform caching");
+      });
+      redisClient.on("reconnecting", () => {
+        metricsCollector.recordReconnect();
+        logger2.debug("Redis reconnecting for platform caching");
+      });
+      await redisClient.connect();
+      redisAvailable = true;
+      if (process.env.NODE_ENV !== "production") {
+        logger2.info("\u2705 Redis client initialized for platform caching with production config");
+      }
+    } catch (error) {
+      logger2.error("Redis initialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      redisAvailable = false;
+    }
+  })();
+  return initializationPromise;
+}
+__name(initializeRedis, "initializeRedis");
+async function getCache(key) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return null;
+  }
+  try {
+    const value = await redisClient.get(key);
+    if (!value) {
+      return null;
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    logger2.error("Redis GET failed", {
+      key,
+      error
+    });
+    return null;
+  }
+}
+__name(getCache, "getCache");
+async function setCache(key, value, ttlSeconds) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return false;
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (ttlSeconds) {
+      await redisClient.set(key, serialized, {
+        EX: ttlSeconds
+      });
+    } else {
+      await redisClient.set(key, serialized);
+    }
+    return true;
+  } catch (error) {
+    logger2.error("Redis SET failed", {
+      key,
+      error
+    });
+    return false;
+  }
+}
+__name(setCache, "setCache");
+async function deleteCache(key) {
+  await initializeRedis();
+  if (!redisAvailable || !redisClient) {
+    return false;
+  }
+  try {
+    await redisClient.del(key);
+    return true;
+  } catch (error) {
+    logger2.error("Redis DEL failed", {
+      key,
+      error
+    });
+    return false;
+  }
+}
+__name(deleteCache, "deleteCache");
+async function closeRedis() {
+  if (redisClient) {
+    try {
+      await redisClient.quit();
+      logger2.info("Redis connection closed");
+    } catch (error) {
+      logger2.error("Error closing Redis connection", {
+        error
+      });
+    }
+    redisClient = null;
+    redisAvailable = false;
+  }
+}
+__name(closeRedis, "closeRedis");
+function isRedisAvailable() {
+  return redisAvailable;
+}
+__name(isRedisAvailable, "isRedisAvailable");
+function getRedisClient() {
+  return redisClient;
+}
+__name(getRedisClient, "getRedisClient");
+
+export { closeRedis, deleteCache, getCache, getRedisClient, initializeRedis, isRedisAvailable, setCache };