shiva-code 0.7.18 → 0.8.2

package/dist/{chunk-UABU5VVI.js → chunk-5RLMQDLT.js}

@@ -187,6 +187,27 @@ var log = {
   // Done message (for completing operations)
   done: (message) => {
     console.log(`${shivaSuccess("\u25CF")} ${message}`);
+  },
+  // Auth required shorthand - for consistent auth error messages
+  authRequired: () => {
+    console.log(shivaError("\u2717"), "Nicht angemeldet");
+    console.log(chalk.dim("  \u2192"), shivaSecondary("Anmelden mit: shiva login"));
+  },
+  // Section header with centered box (like in onboarding)
+  sectionBox: (title, width = 45) => {
+    const innerWidth = width - 2;
+    const visibleLen = title.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "").length;
+    const paddingLeft = Math.floor((innerWidth - visibleLen) / 2);
+    const paddingRight = innerWidth - visibleLen - paddingLeft;
+    console.log(shivaPrimary("  \u256D" + "\u2500".repeat(innerWidth) + "\u256E"));
+    console.log(shivaPrimary("  \u2502") + " ".repeat(paddingLeft) + title + " ".repeat(paddingRight) + shivaPrimary("\u2502"));
+    console.log(shivaPrimary("  \u2570" + "\u2500".repeat(innerWidth) + "\u256F"));
+  },
+  // Inline key-value pairs with consistent padding
+  inlineKeyValue: (pairs) => {
+    for (const { key, value } of pairs) {
+      console.log(`  ${chalk.dim(key.padEnd(15))} ${shivaSecondary(value)}`);
+    }
   }
 };
 var colors = {

package/dist/chunk-FAMO57BL.js

@@ -0,0 +1,417 @@
+import {
+  api
+} from "./chunk-KB6M24M3.js";
+import {
+  getExtendedConfig,
+  setClaudeArgs,
+  setClaudeSkipPermissions,
+  setDefaultTerminal
+} from "./chunk-OP4HYQZZ.js";
+
+// src/services/data/settings-sync.ts
+import * as crypto from "crypto";
+import Conf from "conf";
+var settingsStore = new Conf({
+  projectName: "shiva-code-settings",
+  defaults: {
+    syncableSettings: {
+      version: 1,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      defaultTerminal: "auto",
+      claudeArgs: [],
+      claudeSkipPermissions: true,
+      docker: {
+        enabled: false,
+        defaultImage: "shiva/claude-runner:latest",
+        autoStart: true,
+        volumeMounts: {},
+        environment: {}
+      },
+      language: "de",
+      theme: "auto",
+      features: {
+        autoSync: true,
+        githubContext: true,
+        secretsInjection: true
+      }
+    },
+    syncState: {
+      lastSyncedAt: null,
+      localHash: "",
+      cloudHash: null,
+      conflictStrategy: "manual",
+      pendingChanges: false
+    }
+  }
+});
+var SettingsSyncService = class {
+  // ============================================
+  // Local Settings Management
+  // ============================================
+  /**
+   * Get local syncable settings
+   * Merges config.ts values with syncable settings store
+   */
+  getLocalSettings() {
+    const stored = settingsStore.get("syncableSettings");
+    const extConfig = getExtendedConfig();
+    const settings = {
+      ...stored,
+      defaultTerminal: extConfig.defaultTerminal,
+      claudeArgs: extConfig.claudeArgs,
+      claudeSkipPermissions: extConfig.claudeSkipPermissions,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return settings;
+  }
+  /**
+   * Update local settings
+   */
+  setLocalSettings(settings) {
+    const current = this.getLocalSettings();
+    const updated = {
+      ...current,
+      ...settings,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    settingsStore.set("syncableSettings", updated);
+    if (settings.defaultTerminal !== void 0) {
+      setDefaultTerminal(settings.defaultTerminal);
+    }
+    if (settings.claudeArgs !== void 0) {
+      setClaudeArgs(settings.claudeArgs);
+    }
+    if (settings.claudeSkipPermissions !== void 0) {
+      setClaudeSkipPermissions(settings.claudeSkipPermissions);
+    }
+    this.updateSyncState({ pendingChanges: true });
+  }
+  /**
+   * Calculate hash of settings for conflict detection
+   */
+  getLocalHash() {
+    const settings = this.getLocalSettings();
+    const { lastModified, ...hashable } = settings;
+    return crypto.createHash("md5").update(JSON.stringify(hashable)).digest("hex").substring(0, 8);
+  }
+  // ============================================
+  // Sync State Management
+  // ============================================
+  /**
+   * Get current sync state
+   */
+  getSyncState() {
+    const state = settingsStore.get("syncState");
+    return {
+      ...state,
+      localHash: this.getLocalHash()
+    };
+  }
+  /**
+   * Update sync state
+   */
+  updateSyncState(partial) {
+    const current = settingsStore.get("syncState");
+    settingsStore.set("syncState", { ...current, ...partial });
+  }
+  /**
+   * Set conflict resolution strategy
+   */
+  setConflictStrategy(strategy) {
+    this.updateSyncState({ conflictStrategy: strategy });
+  }
+  // ============================================
+  // Cloud Sync Operations
+  // ============================================
+  /**
+   * Get settings from cloud
+   */
+  async getCloudSettings() {
+    try {
+      const response = await api.getUserSettings();
+      return response.settings || null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Push local settings to cloud
+   */
+  async pushToCloud(settings) {
+    const localSettings = settings || this.getLocalSettings();
+    const localHash = this.getLocalHash();
+    await api.updateUserSettings({
+      settings: localSettings,
+      localHash
+    });
+    this.updateSyncState({
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cloudHash: localHash,
+      pendingChanges: false
+    });
+  }
+  /**
+   * Pull settings from cloud and apply locally
+   */
+  async pullFromCloud() {
+    const cloudSettings = await this.getCloudSettings();
+    if (!cloudSettings) {
+      throw new Error("No cloud settings found");
+    }
+    this.setLocalSettings(cloudSettings);
+    const cloudHash = this.calculateHash(cloudSettings);
+    this.updateSyncState({
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cloudHash,
+      pendingChanges: false
+    });
+    return cloudSettings;
+  }
+  /**
+   * Calculate hash for any settings object
+   */
+  calculateHash(settings) {
+    const { lastModified, ...hashable } = settings;
+    return crypto.createHash("md5").update(JSON.stringify(hashable)).digest("hex").substring(0, 8);
+  }
+  // ============================================
+  // Sync Operations
+  // ============================================
+  /**
+   * Check if local and cloud are out of sync
+   */
+  async isOutOfSync() {
+    const cloudSettings = await this.getCloudSettings();
+    if (!cloudSettings) {
+      return true;
+    }
+    const localHash = this.getLocalHash();
+    const cloudHash = this.calculateHash(cloudSettings);
+    return localHash !== cloudHash;
+  }
+  /**
+   * Perform sync with optional strategy override
+   */
+  async sync(strategy) {
+    const resolveStrategy = strategy || this.getSyncState().conflictStrategy;
+    const localSettings = this.getLocalSettings();
+    const localHash = this.getLocalHash();
+    try {
+      const response = await api.syncUserSettings({
+        settings: localSettings,
+        localHash
+      });
+      if (response.conflict) {
+        if (resolveStrategy === "local-wins") {
+          await api.updateUserSettings({
+            settings: localSettings,
+            localHash,
+            forceOverwrite: true
+          });
+          this.updateSyncState({
+            lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            cloudHash: localHash,
+            pendingChanges: false
+          });
+          return {
+            success: true,
+            action: "pushed",
+            settings: localSettings,
+            message: "Lokale Einstellungen hochgeladen (local-wins)"
+          };
+        }
+        if (resolveStrategy === "cloud-wins") {
+          const cloudSettings = response.conflict.cloudSettings;
+          this.setLocalSettings(cloudSettings);
+          const cloudHash = this.calculateHash(cloudSettings);
+          this.updateSyncState({
+            lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            cloudHash,
+            pendingChanges: false
+          });
+          return {
+            success: true,
+            action: "pulled",
+            settings: cloudSettings,
+            message: "Cloud-Einstellungen \xFCbernommen (cloud-wins)"
+          };
+        }
+        return {
+          success: false,
+          action: "conflict",
+          conflict: {
+            type: response.conflict.type,
+            localSettings,
+            cloudSettings: response.conflict.cloudSettings
+          },
+          message: "Konflikt erkannt. Manuelle Aufl\xF6sung erforderlich."
+        };
+      }
+      this.updateSyncState({
+        lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cloudHash: response.cloudHash,
+        pendingChanges: false
+      });
+      return {
+        success: true,
+        action: "pushed",
+        settings: response.settings,
+        message: "Sync erfolgreich"
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        await this.pushToCloud(localSettings);
+        return {
+          success: true,
+          action: "pushed",
+          settings: localSettings,
+          message: "Erste Synchronisation erfolgreich"
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Merge settings from local and cloud
+   */
+  mergeSettings(local, cloud) {
+    const localTime = new Date(local.lastModified).getTime();
+    const cloudTime = new Date(cloud.lastModified).getTime();
+    return {
+      version: Math.max(local.version, cloud.version),
+      lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      // CLI-specific: prefer local
+      defaultTerminal: local.defaultTerminal,
+      claudeArgs: local.claudeArgs,
+      claudeSkipPermissions: local.claudeSkipPermissions,
+      // Docker: merge
+      docker: {
+        ...cloud.docker,
+        ...local.docker,
+        volumeMounts: { ...cloud.docker.volumeMounts, ...local.docker.volumeMounts },
+        environment: { ...cloud.docker.environment, ...local.docker.environment }
+      },
+      // Preferences: prefer newer
+      language: localTime > cloudTime ? local.language : cloud.language,
+      theme: localTime > cloudTime ? local.theme : cloud.theme,
+      // Features: prefer cloud (browser-configurable)
+      features: cloud.features
+    };
+  }
+  /**
+   * Resolve conflict with specific resolution
+   */
+  async resolveConflict(resolution) {
+    const localSettings = this.getLocalSettings();
+    const cloudSettings = await this.getCloudSettings();
+    if (!cloudSettings) {
+      await this.pushToCloud(localSettings);
+      return {
+        success: true,
+        action: "pushed",
+        settings: localSettings,
+        message: "Lokale Einstellungen hochgeladen"
+      };
+    }
+    let finalSettings;
+    let action;
+    switch (resolution) {
+      case "local":
+        finalSettings = localSettings;
+        action = "pushed";
+        break;
+      case "cloud":
+        finalSettings = cloudSettings;
+        action = "pulled";
+        break;
+      case "merge":
+        finalSettings = this.mergeSettings(localSettings, cloudSettings);
+        action = "merged";
+        break;
+    }
+    if (resolution === "cloud") {
+      this.setLocalSettings(finalSettings);
+    } else {
+      await api.updateUserSettings({
+        settings: finalSettings,
+        localHash: this.calculateHash(finalSettings),
+        forceOverwrite: true
+      });
+    }
+    const finalHash = this.calculateHash(finalSettings);
+    this.updateSyncState({
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cloudHash: finalHash,
+      pendingChanges: false
+    });
+    return {
+      success: true,
+      action,
+      settings: finalSettings,
+      message: `Konflikt aufgel\xF6st: ${resolution}`
+    };
+  }
+  // ============================================
+  // Docker Settings Helpers
+  // ============================================
+  /**
+   * Get Docker settings
+   */
+  getDockerSettings() {
+    return this.getLocalSettings().docker;
+  }
+  /**
+   * Update Docker settings
+   */
+  setDockerSettings(docker) {
+    const current = this.getLocalSettings();
+    this.setLocalSettings({
+      docker: { ...current.docker, ...docker }
+    });
+  }
+  /**
+   * Enable/disable Docker mode
+   */
+  setDockerEnabled(enabled) {
+    this.setDockerSettings({ enabled });
+  }
+  /**
+   * Set default Docker image
+   */
+  setDockerImage(image) {
+    this.setDockerSettings({ defaultImage: image });
+  }
+  // ============================================
+  // Feature Flags
+  // ============================================
+  /**
+   * Get feature flags
+   */
+  getFeatures() {
+    return this.getLocalSettings().features;
+  }
+  /**
+   * Set feature flag
+   */
+  setFeature(feature, enabled) {
+    const current = this.getLocalSettings();
+    this.setLocalSettings({
+      features: { ...current.features, [feature]: enabled }
+    });
+  }
+  // ============================================
+  // Settings History (for debugging)
+  // ============================================
+  /**
+   * Get settings history from cloud
+   */
+  async getHistory() {
+    return api.getSettingsHistory();
+  }
+};
+var settingsSync = new SettingsSyncService();
+
+export {
+  SettingsSyncService,
+  settingsSync
+};

package/dist/{chunk-W3DKHCXB.js → chunk-GHGMDDLO.js}

@@ -95,7 +95,53 @@ function encodeProjectPath(projectPath) {
 }
 function decodeProjectPath(encoded) {
   const parts = encoded.split("-").filter(Boolean);
-  return "/" + parts.join("/");
+  let currentPath = "";
+  let i = 0;
+  while (i < parts.length) {
+    const part = parts[i];
+    const testPath = currentPath + "/" + part;
+    if (fs.existsSync(testPath)) {
+      currentPath = testPath;
+      i++;
+    } else {
+      let found = false;
+      for (let j = i + 1; j < parts.length && j <= i + 5 && !found; j++) {
+        const partsToJoin = parts.slice(i, j + 1);
+        const withHyphen = partsToJoin.join("-");
+        const hyphenPath = currentPath + "/" + withHyphen;
+        if (fs.existsSync(hyphenPath)) {
+          currentPath = hyphenPath;
+          i = j + 1;
+          found = true;
+          break;
+        }
+        const withDot = partsToJoin.join(".");
+        const dotPath = currentPath + "/" + withDot;
+        if (fs.existsSync(dotPath)) {
+          currentPath = dotPath;
+          i = j + 1;
+          found = true;
+          break;
+        }
+        const withUnderscore = partsToJoin.join("_");
+        const underscorePath = currentPath + "/" + withUnderscore;
+        if (fs.existsSync(underscorePath)) {
+          currentPath = underscorePath;
+          i = j + 1;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        currentPath = testPath;
+        i++;
+      }
+    }
+  }
+  if (!currentPath || currentPath === "/") {
+    return "/" + parts.join("/");
+  }
+  return currentPath;
 }
 function getProjectName(projectPath) {
   return path2.basename(projectPath);

package/dist/{chunk-KUA6TMQJ.js → chunk-HNIWPFMY.js}

@@ -1,7 +1,7 @@
 import {
   findProject,
   getProjectName
-} from "./chunk-W3DKHCXB.js";
+} from "./chunk-GHGMDDLO.js";
 
 // src/services/data/package-manager.ts
 import Conf from "conf";