shiva-code 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1144 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import inquirer2 from "inquirer";
+
+// src/utils/config.ts
+import Conf from "conf";
+var DEFAULT_API_ENDPOINT = "https://shiva-ai-api.slither-mutiplayer.workers.dev/api";
+var config = new Conf({
+  projectName: "shiva-code",
+  defaults: {
+    apiEndpoint: DEFAULT_API_ENDPOINT,
+    token: null,
+    tokenExpiry: null,
+    userId: null,
+    email: null,
+    tier: null
+  }
+});
+function getConfig() {
+  return {
+    apiEndpoint: config.get("apiEndpoint"),
+    token: config.get("token"),
+    tokenExpiry: config.get("tokenExpiry"),
+    userId: config.get("userId"),
+    email: config.get("email"),
+    tier: config.get("tier")
+  };
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function getToken() {
+  const token = config.get("token");
+  const expiry = config.get("tokenExpiry");
+  if (token && expiry && Date.now() > expiry) {
+    clearAuth();
+    return null;
+  }
+  return token;
+}
+function setAuth(token, user) {
+  let expiry;
+  try {
+    const payload = JSON.parse(atob(token.includes(".") ? token.split(".")[1] : token));
+    expiry = payload.exp > 1e12 ? payload.exp : payload.exp * 1e3;
+  } catch {
+    expiry = Date.now() + 7 * 24 * 60 * 60 * 1e3;
+  }
+  config.set("token", token);
+  config.set("tokenExpiry", expiry);
+  config.set("userId", user.id);
+  config.set("email", user.email);
+  config.set("tier", user.tier);
+}
+function clearAuth() {
+  config.set("token", null);
+  config.set("tokenExpiry", null);
+  config.set("userId", null);
+  config.set("email", null);
+  config.set("tier", null);
+}
+function isAuthenticated() {
+  return getToken() !== null;
+}
+function getApiEndpoint() {
+  return config.get("apiEndpoint");
+}
+var CONFIG_PATH = config.path;
+function clearConfig() {
+  config.clear();
+  config.set("apiEndpoint", DEFAULT_API_ENDPOINT);
+}
+
+// src/services/api.ts
+var ApiClient = class {
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const token = getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  async request(endpoint, options = {}) {
+    const baseUrl = getApiEndpoint();
+    const url = `${baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.getHeaders(),
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || error.message || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  // Auth endpoints
+  async requestOtp(email) {
+    return this.request("/auth/otp/request", {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  async verifyOtp(token, otp) {
+    return this.request("/auth/otp/verify", {
+      method: "POST",
+      body: JSON.stringify({ token, otp })
+    });
+  }
+  async getCurrentUser() {
+    return this.request("/auth/me");
+  }
+  // Project endpoints
+  async getProjects() {
+    return this.request("/projects");
+  }
+  async getProject(id) {
+    return this.request(`/projects/${id}`);
+  }
+  async createOrUpdateProject(data) {
+    return this.request("/projects", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async syncProject(id, data) {
+    return this.request(`/projects/${id}/sync`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteProject(id) {
+    return this.request(`/projects/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async addMemory(projectId, memory) {
+    return this.request(`/projects/${projectId}/memories`, {
+      method: "POST",
+      body: JSON.stringify(memory)
+    });
+  }
+  async connectProjects(projectA, projectB, connectionType) {
+    return this.request("/projects/connect", {
+      method: "POST",
+      body: JSON.stringify({
+        projectA,
+        projectB,
+        connectionType: connectionType || "related"
+      })
+    });
+  }
+  async disconnectProjects(projectA, projectB) {
+    return this.request("/projects/disconnect", {
+      method: "DELETE",
+      body: JSON.stringify({ projectA, projectB })
+    });
+  }
+  async getStats() {
+    return this.request("/projects/stats");
+  }
+  // Find project by path
+  async findProjectByPath(path) {
+    const projects = await this.getProjects();
+    return projects.find((p) => p.path === path) || null;
+  }
+};
+var api = new ApiClient();
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  // Success messages
+  success: (message) => console.log(chalk.green("\u2713"), message),
+  // Error messages
+  error: (message) => console.log(chalk.red("\u2717"), message),
+  // Warning messages
+  warn: (message) => console.log(chalk.yellow("\u26A0"), message),
+  // Info messages
+  info: (message) => console.log(chalk.blue("\u2139"), message),
+  // Plain message
+  plain: (message) => console.log(message),
+  // Dimmed text
+  dim: (message) => console.log(chalk.dim(message)),
+  // Bold text
+  bold: (message) => console.log(chalk.bold(message)),
+  // Newline
+  newline: () => console.log(),
+  // Header
+  header: (title) => {
+    console.log();
+    console.log(chalk.bold(title));
+    console.log(chalk.dim("\u2500".repeat(title.length)));
+  },
+  // Key-value pair
+  keyValue: (key, value, indent = 0) => {
+    const spaces = " ".repeat(indent);
+    console.log(`${spaces}${chalk.dim(key + ":")} ${value}`);
+  },
+  // List item
+  listItem: (text, status) => {
+    let icon = "\u2022";
+    if (status === "synced") icon = chalk.green("\u2713");
+    if (status === "pending") icon = chalk.yellow("\u25CB");
+    if (status === "error") icon = chalk.red("\u2717");
+    console.log(`  ${icon} ${text}`);
+  },
+  // Tree structure
+  tree: {
+    item: (text, isLast = false) => {
+      const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+      console.log(chalk.dim(prefix), text);
+    }
+  },
+  // Branded header
+  brand: () => {
+    console.log();
+    console.log(chalk.hex("#FF6B2C").bold("SHIVA Code"));
+    console.log(chalk.dim("Makes Claude Code Persistent"));
+    console.log();
+  }
+};
+var colors = {
+  orange: chalk.hex("#FF6B2C"),
+  cyan: chalk.hex("#00D4FF"),
+  green: chalk.green,
+  red: chalk.red,
+  yellow: chalk.yellow,
+  dim: chalk.dim,
+  bold: chalk.bold
+};
+
+// src/services/auth.ts
+import inquirer from "inquirer";
+import open from "open";
+async function loginWithOtp(email) {
+  try {
+    log.info(`Sende Login-Code an ${email}...`);
+    const otpResponse = await api.requestOtp(email);
+    if (!otpResponse.success) {
+      log.error(otpResponse.message || "Fehler beim Senden des Codes");
+      return false;
+    }
+    log.success("Code wurde gesendet!");
+    log.dim(`Verbleibende Versuche: ${otpResponse.remainingAttempts}`);
+    log.newline();
+    const { otp } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "otp",
+        message: "Code eingeben:",
+        validate: (input) => {
+          if (!/^\d{6}$/.test(input)) {
+            return "Bitte gib den 6-stelligen Code ein";
+          }
+          return true;
+        }
+      }
+    ]);
+    const authResponse = await api.verifyOtp(otpResponse.token, otp);
+    if (!authResponse.success || !authResponse.token || !authResponse.user) {
+      log.error(authResponse.message || "Ung\xFCltiger Code");
+      return false;
+    }
+    setAuth(authResponse.token, authResponse.user);
+    log.newline();
+    log.success(`Angemeldet als ${authResponse.user.email} (${authResponse.user.tier.toUpperCase()})`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unbekannter Fehler";
+    log.error(`Login fehlgeschlagen: ${message}`);
+    return false;
+  }
+}
+async function loginWithBrowser() {
+  const config2 = getConfig();
+  const loginUrl = `${config2.apiEndpoint.replace("/api", "")}/auth/cli-login`;
+  log.info("\xD6ffne Browser zur Anmeldung...");
+  log.dim(`URL: ${loginUrl}`);
+  log.newline();
+  try {
+    await open(loginUrl);
+    log.plain("Nachdem du dich im Browser angemeldet hast,");
+    log.plain("kopiere den Token und f\xFCge ihn hier ein:");
+    log.newline();
+    const { token } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "token",
+        message: "Token:",
+        mask: "*"
+      }
+    ]);
+    if (!token) {
+      log.error("Kein Token eingegeben");
+      return false;
+    }
+    const originalToken = config2.token;
+    setAuth(token, { id: 0, email: "", tier: "free" });
+    try {
+      const response = await api.getCurrentUser();
+      setAuth(token, response.user);
+      log.newline();
+      log.success(`Angemeldet als ${response.user.email} (${response.user.tier.toUpperCase()})`);
+      return true;
+    } catch {
+      if (originalToken) {
+        setAuth(originalToken, { id: config2.userId, email: config2.email, tier: config2.tier });
+      } else {
+        clearAuth();
+      }
+      log.error("Ung\xFCltiger Token");
+      return false;
+    }
+  } catch (error) {
+    log.error("Konnte Browser nicht \xF6ffnen");
+    return false;
+  }
+}
+function logout() {
+  clearAuth();
+  log.success("Abgemeldet");
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Mit shiva.li anmelden").option("-e, --email <email>", "Email-Adresse f\xFCr OTP-Login").option("-b, --browser", "Im Browser anmelden").action(async (options) => {
+  if (isAuthenticated()) {
+    const config2 = getConfig();
+    log.info(`Bereits angemeldet als ${config2.email}`);
+    const { relogin } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "relogin",
+        message: "M\xF6chtest du dich neu anmelden?",
+        default: false
+      }
+    ]);
+    if (!relogin) {
+      return;
+    }
+  }
+  log.brand();
+  if (options.browser) {
+    await loginWithBrowser();
+    return;
+  }
+  if (options.email) {
+    await loginWithOtp(options.email);
+    return;
+  }
+  const { email } = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "email",
+      message: "Email-Adresse:",
+      validate: (input) => {
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)) {
+          return "Bitte gib eine g\xFCltige Email-Adresse ein";
+        }
+        return true;
+      }
+    }
+  ]);
+  await loginWithOtp(email);
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Abmelden").action(() => {
+  if (!isAuthenticated()) {
+    log.info("Du bist nicht angemeldet");
+    return;
+  }
+  logout();
+});
+
+// src/commands/init.ts
+import { Command as Command3 } from "commander";
+import { writeFileSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import ora from "ora";
+import inquirer3 from "inquirer";
+
+// src/services/scanner.ts
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { resolve, basename } from "path";
+async function scanProject(dir) {
+  const absolutePath = resolve(dir);
+  const projectName = basename(absolutePath);
+  const result = {
+    name: projectName,
+    path: absolutePath,
+    hasClaudeMd: false
+  };
+  const claudeMdPath = resolve(absolutePath, "CLAUDE.md");
+  if (existsSync(claudeMdPath)) {
+    result.hasClaudeMd = true;
+    result.claudeMdContent = readFileSync(claudeMdPath, "utf-8");
+  }
+  const packageJsonPath = resolve(absolutePath, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      if (pkg.name) result.name = pkg.name;
+      if (pkg.description) result.description = pkg.description;
+      result.language = detectLanguageFromPackage(pkg, absolutePath);
+      result.framework = detectFramework(pkg);
+      result.packageManager = detectPackageManager(absolutePath);
+    } catch {
+    }
+  }
+  if (!result.language) {
+    result.language = detectLanguageFromFiles(absolutePath);
+  }
+  if (!result.language) {
+    const pyprojectPath = resolve(absolutePath, "pyproject.toml");
+    const requirementsPath = resolve(absolutePath, "requirements.txt");
+    if (existsSync(pyprojectPath) || existsSync(requirementsPath)) {
+      result.language = "Python";
+      result.packageManager = existsSync(pyprojectPath) ? "poetry" : "pip";
+    }
+  }
+  if (!result.language) {
+    const goModPath = resolve(absolutePath, "go.mod");
+    if (existsSync(goModPath)) {
+      result.language = "Go";
+      result.packageManager = "go mod";
+    }
+  }
+  if (!result.language) {
+    const cargoPath = resolve(absolutePath, "Cargo.toml");
+    if (existsSync(cargoPath)) {
+      result.language = "Rust";
+      result.packageManager = "cargo";
+    }
+  }
+  return result;
+}
+function detectLanguageFromPackage(pkg, dir) {
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (allDeps["typescript"] || existsSync(resolve(dir, "tsconfig.json"))) {
+    return "TypeScript";
+  }
+  return "JavaScript";
+}
+function detectFramework(pkg) {
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (allDeps["next"]) return "Next.js";
+  if (allDeps["nuxt"]) return "Nuxt";
+  if (allDeps["@sveltejs/kit"]) return "SvelteKit";
+  if (allDeps["astro"]) return "Astro";
+  if (allDeps["react"]) return "React";
+  if (allDeps["vue"]) return "Vue";
+  if (allDeps["svelte"]) return "Svelte";
+  if (allDeps["angular"]) return "Angular";
+  if (allDeps["express"]) return "Express";
+  if (allDeps["fastify"]) return "Fastify";
+  if (allDeps["hono"]) return "Hono";
+  if (allDeps["koa"]) return "Koa";
+  if (allDeps["nestjs"] || allDeps["@nestjs/core"]) return "NestJS";
+  if (allDeps["electron"]) return "Electron";
+  if (allDeps["react-native"]) return "React Native";
+  return void 0;
+}
+function detectPackageManager(dir) {
+  if (existsSync(resolve(dir, "bun.lockb"))) return "bun";
+  if (existsSync(resolve(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(resolve(dir, "yarn.lock"))) return "yarn";
+  if (existsSync(resolve(dir, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function detectLanguageFromFiles(dir) {
+  try {
+    const files = readdirSync(dir);
+    const hasTs = files.some((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+    const hasJs = files.some((f) => f.endsWith(".js") || f.endsWith(".jsx"));
+    const hasPy = files.some((f) => f.endsWith(".py"));
+    const hasGo = files.some((f) => f.endsWith(".go"));
+    const hasRs = files.some((f) => f.endsWith(".rs"));
+    if (hasTs) return "TypeScript";
+    if (hasJs) return "JavaScript";
+    if (hasPy) return "Python";
+    if (hasGo) return "Go";
+    if (hasRs) return "Rust";
+  } catch {
+  }
+  return void 0;
+}
+
+// src/services/claude-md.ts
+function generateClaudeMd(scanned, project) {
+  const lines = [];
+  lines.push(`# ${scanned.name}`);
+  lines.push("");
+  lines.push("## Project Overview");
+  if (scanned.description) {
+    lines.push(scanned.description);
+  } else {
+    lines.push("<!-- Add project description here -->");
+  }
+  lines.push("");
+  lines.push("## Tech Stack");
+  if (scanned.language) {
+    lines.push(`- **Language**: ${scanned.language}`);
+  }
+  if (scanned.framework) {
+    lines.push(`- **Framework**: ${scanned.framework}`);
+  }
+  if (scanned.packageManager) {
+    lines.push(`- **Package Manager**: ${scanned.packageManager}`);
+  }
+  lines.push("");
+  lines.push("## SHIVA Code");
+  lines.push("");
+  lines.push("This project is managed by [SHIVA Code](https://shiva.li).");
+  lines.push("");
+  if (project) {
+    lines.push(`- **Status**: ${project.synced ? "Synced" : "Pending"}`);
+    if (project.last_synced_at) {
+      lines.push(`- **Last Sync**: ${new Date(project.last_synced_at).toLocaleString()}`);
+    }
+    lines.push(`- **Project ID**: ${project.id}`);
+  } else {
+    lines.push("- **Status**: Not synced");
+    lines.push("- **Last Sync**: Never");
+  }
+  lines.push("");
+  lines.push("## Memories");
+  lines.push("");
+  if (project?.memories && project.memories.length > 0) {
+    lines.push("The following context is remembered across sessions:");
+    lines.push("");
+    for (const memory of project.memories) {
+      lines.push(`- **${memory.key}** (${memory.category}): ${memory.value}`);
+    }
+  } else {
+    lines.push("No memories stored yet. Use `shiva sync` to sync your project.");
+  }
+  lines.push("");
+  if (project?.connections && project.connections.length > 0) {
+    lines.push("## Connected Projects");
+    lines.push("");
+    lines.push("This project is connected to:");
+    lines.push("");
+    for (const conn of project.connections) {
+      lines.push(`- **${conn.connected_project_name}** (${conn.connection_type})`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by SHIVA Code CLI*");
+  return lines.join("\n");
+}
+function parseClaudeMd(content) {
+  const memories = [];
+  const memoryRegex = /^- \*\*(.+?)\*\* \((.+?)\): (.+)$/gm;
+  let match;
+  while ((match = memoryRegex.exec(content)) !== null) {
+    memories.push({
+      key: match[1],
+      category: match[2],
+      value: match[3]
+    });
+  }
+  return { memories };
+}
+
+// src/commands/init.ts
+var initCommand = new Command3("init").description("Projekt f\xFCr SHIVA Code initialisieren").option("-d, --dir <directory>", "Projektverzeichnis", ".").option("-f, --force", "CLAUDE.md \xFCberschreiben wenn vorhanden").option("--no-sync", "Nicht mit Cloud synchronisieren").action(async (options) => {
+  log.brand();
+  const projectDir = resolve2(options.dir);
+  if (!existsSync2(projectDir)) {
+    log.error(`Verzeichnis nicht gefunden: ${projectDir}`);
+    return;
+  }
+  const spinner = ora("Projekt wird gescannt...").start();
+  let scanned;
+  try {
+    scanned = await scanProject(projectDir);
+    spinner.succeed("Projekt gescannt");
+  } catch (error) {
+    spinner.fail("Fehler beim Scannen");
+    log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+    return;
+  }
+  log.newline();
+  log.header("Erkannt");
+  log.keyValue("Name", scanned.name, 2);
+  if (scanned.language) log.keyValue("Sprache", scanned.language, 2);
+  if (scanned.framework) log.keyValue("Framework", scanned.framework, 2);
+  if (scanned.packageManager) log.keyValue("Package Manager", scanned.packageManager, 2);
+  log.newline();
+  const claudeMdPath = resolve2(projectDir, "CLAUDE.md");
+  if (existsSync2(claudeMdPath) && !options.force) {
+    const { overwrite } = await inquirer3.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "CLAUDE.md existiert bereits. \xDCberschreiben?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      log.info("CLAUDE.md wurde nicht ver\xE4ndert");
+      return;
+    }
+  }
+  let project = null;
+  if (options.sync && isAuthenticated()) {
+    const syncSpinner = ora("Synchronisiere mit Cloud...").start();
+    try {
+      const result = await api.createOrUpdateProject({
+        name: scanned.name,
+        path: scanned.path,
+        description: scanned.description,
+        metadata: {
+          language: scanned.language,
+          framework: scanned.framework,
+          packageManager: scanned.packageManager
+        }
+      });
+      project = await api.getProject(result.projectId);
+      syncSpinner.succeed(`Projekt ${result.action === "created" ? "erstellt" : "aktualisiert"}`);
+    } catch (error) {
+      syncSpinner.warn("Cloud-Sync fehlgeschlagen (offline?)");
+    }
+  } else if (!isAuthenticated()) {
+    log.dim('Tipp: Mit "shiva login" anmelden f\xFCr Cloud-Sync');
+  }
+  const claudeMdContent = generateClaudeMd(scanned, project || void 0);
+  writeFileSync(claudeMdPath, claudeMdContent);
+  log.success("CLAUDE.md erstellt");
+  log.newline();
+  log.success("Projekt initialisiert!");
+  if (!isAuthenticated()) {
+    log.newline();
+    log.info("N\xE4chste Schritte:");
+    log.plain("  1. shiva login    - Anmelden");
+    log.plain("  2. shiva sync     - Mit Cloud synchronisieren");
+  }
+});
+
+// src/commands/sync.ts
+import { Command as Command4 } from "commander";
+import { writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import ora2 from "ora";
+var syncCommand = new Command4("sync").description("Projekt mit Cloud synchronisieren").option("-d, --dir <directory>", "Projektverzeichnis", ".").option("--pull", "Nur von Cloud herunterladen").option("--push", "Nur zu Cloud hochladen").action(async (options) => {
+  if (!isAuthenticated()) {
+    log.error('Nicht angemeldet. Bitte zuerst "shiva login" ausf\xFChren.');
+    return;
+  }
+  const projectDir = resolve3(options.dir);
+  if (!existsSync3(projectDir)) {
+    log.error(`Verzeichnis nicht gefunden: ${projectDir}`);
+    return;
+  }
+  const spinner = ora2("Synchronisiere...").start();
+  let scanned;
+  try {
+    scanned = await scanProject(projectDir);
+  } catch (error) {
+    spinner.fail("Fehler beim Scannen");
+    return;
+  }
+  let project = await api.findProjectByPath(scanned.path);
+  if (!project) {
+    spinner.text = "Erstelle Projekt...";
+    try {
+      const result = await api.createOrUpdateProject({
+        name: scanned.name,
+        path: scanned.path,
+        description: scanned.description,
+        metadata: {
+          language: scanned.language,
+          framework: scanned.framework,
+          packageManager: scanned.packageManager
+        },
+        claude_md_content: scanned.claudeMdContent
+      });
+      project = await api.getProject(result.projectId);
+    } catch (error) {
+      spinner.fail("Fehler beim Erstellen");
+      log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+      return;
+    }
+  }
+  let memories = [];
+  if (scanned.claudeMdContent) {
+    const parsed = parseClaudeMd(scanned.claudeMdContent);
+    memories = parsed.memories;
+  }
+  if (!options.pull) {
+    spinner.text = "Hochladen...";
+    try {
+      await api.syncProject(project.id, {
+        claude_md_content: scanned.claudeMdContent,
+        metadata: {
+          language: scanned.language,
+          framework: scanned.framework,
+          packageManager: scanned.packageManager
+        },
+        memories
+      });
+    } catch (error) {
+      spinner.fail("Fehler beim Hochladen");
+      log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+      return;
+    }
+  }
+  if (!options.push) {
+    spinner.text = "Aktualisiere CLAUDE.md...";
+    try {
+      project = await api.getProject(project.id);
+      const newClaudeMd = generateClaudeMd(scanned, project);
+      const claudeMdPath = resolve3(projectDir, "CLAUDE.md");
+      writeFileSync2(claudeMdPath, newClaudeMd);
+    } catch (error) {
+      spinner.fail("Fehler beim Aktualisieren");
+      log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+      return;
+    }
+  }
+  spinner.succeed("Synchronisiert");
+  log.newline();
+  log.tree.item("CLAUDE.md aktualisiert");
+  log.tree.item(`${project.memories?.length || 0} Memories synchronisiert`);
+  log.tree.item("Metadata aktualisiert", true);
+  log.newline();
+  log.success(`Sync erfolgreich (${(/* @__PURE__ */ new Date()).toLocaleTimeString()})`);
+});
+
+// src/commands/status.ts
+import { Command as Command5 } from "commander";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+var statusCommand = new Command5("status").description("Status des aktuellen Projekts anzeigen").option("-d, --dir <directory>", "Projektverzeichnis", ".").action(async (options) => {
+  log.brand();
+  const projectDir = resolve4(options.dir);
+  if (!existsSync4(projectDir)) {
+    log.error(`Verzeichnis nicht gefunden: ${projectDir}`);
+    return;
+  }
+  let scanned;
+  try {
+    scanned = await scanProject(projectDir);
+  } catch (error) {
+    log.error("Fehler beim Scannen des Projekts");
+    return;
+  }
+  log.header("SHIVA Code Status");
+  log.keyValue("Projekt", scanned.name);
+  log.keyValue("Pfad", scanned.path);
+  if (scanned.language) log.keyValue("Sprache", scanned.language);
+  if (scanned.framework) log.keyValue("Framework", scanned.framework);
+  log.newline();
+  if (scanned.hasClaudeMd) {
+    log.listItem("CLAUDE.md vorhanden", "synced");
+  } else {
+    log.listItem("CLAUDE.md fehlt", "pending");
+    log.dim('  \u2192 F\xFChre "shiva init" aus');
+  }
+  if (!isAuthenticated()) {
+    log.newline();
+    log.listItem("Nicht angemeldet", "pending");
+    log.dim('  \u2192 F\xFChre "shiva login" aus');
+    return;
+  }
+  log.newline();
+  log.keyValue("Cloud Status", "...");
+  try {
+    const project = await api.findProjectByPath(scanned.path);
+    process.stdout.write("\x1B[1A\x1B[2K");
+    if (project) {
+      if (project.synced) {
+        log.keyValue("Cloud Sync", colors.green("\u2713 Synchronisiert"));
+      } else {
+        log.keyValue("Cloud Sync", colors.yellow("\u25CB Ausstehend"));
+      }
+      if (project.last_synced_at) {
+        const lastSync = new Date(project.last_synced_at);
+        const now = /* @__PURE__ */ new Date();
+        const diff = now.getTime() - lastSync.getTime();
+        const minutes = Math.floor(diff / 6e4);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        let timeAgo;
+        if (days > 0) timeAgo = `vor ${days} Tag${days > 1 ? "en" : ""}`;
+        else if (hours > 0) timeAgo = `vor ${hours} Stunde${hours > 1 ? "n" : ""}`;
+        else if (minutes > 0) timeAgo = `vor ${minutes} Minute${minutes > 1 ? "n" : ""}`;
+        else timeAgo = "gerade eben";
+        log.keyValue("Letzter Sync", timeAgo);
+      }
+      log.newline();
+      log.keyValue("Memories", String(project.memories?.length || 0));
+      log.keyValue("Connections", String(project.connections?.length || 0));
+    } else {
+      log.keyValue("Cloud Sync", colors.yellow("\u25CB Nicht synchronisiert"));
+      log.dim('  \u2192 F\xFChre "shiva sync" aus');
+    }
+    log.newline();
+    const stats = await api.getStats();
+    const config2 = getConfig();
+    log.keyValue(
+      "Tier",
+      `${config2.tier?.toUpperCase() || "FREE"} (${stats.projects.total}/${stats.projects.limit} Projekte)`
+    );
+  } catch (error) {
+    process.stdout.write("\x1B[1A\x1B[2K");
+    log.keyValue("Cloud Sync", colors.red("\u2717 Offline"));
+    log.dim("  \u2192 Keine Verbindung zur Cloud");
+  }
+});
+
+// src/commands/projects.ts
+import { Command as Command6 } from "commander";
+import ora3 from "ora";
+var projectsCommand = new Command6("projects").description("Alle Projekte auflisten").option("-v, --verbose", "Mehr Details anzeigen").action(async (options) => {
+  if (!isAuthenticated()) {
+    log.error('Nicht angemeldet. Bitte zuerst "shiva login" ausf\xFChren.');
+    return;
+  }
+  const spinner = ora3("Lade Projekte...").start();
+  try {
+    const [projects, stats] = await Promise.all([
+      api.getProjects(),
+      api.getStats()
+    ]);
+    spinner.stop();
+    log.newline();
+    log.header(`Deine Projekte (${stats.projects.total}/${stats.projects.limit})`);
+    log.newline();
+    if (projects.length === 0) {
+      log.dim("Keine Projekte gefunden.");
+      log.newline();
+      log.info('Starte mit "shiva init" in einem Projektverzeichnis.');
+      return;
+    }
+    projects.sort((a, b) => {
+      const aTime = new Date(a.updated_at).getTime();
+      const bTime = new Date(b.updated_at).getTime();
+      return bTime - aTime;
+    });
+    for (let i = 0; i < projects.length; i++) {
+      const project = projects[i];
+      const status = project.synced ? "synced" : "pending";
+      const statusIcon = project.synced ? colors.green("\u2713") : colors.yellow("\u25CB");
+      const statusText = project.synced ? "synced" : "pending";
+      let timeAgo = "nie";
+      if (project.last_synced_at) {
+        const lastSync = new Date(project.last_synced_at);
+        const now = /* @__PURE__ */ new Date();
+        const diff = now.getTime() - lastSync.getTime();
+        const minutes = Math.floor(diff / 6e4);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) timeAgo = `vor ${days}d`;
+        else if (hours > 0) timeAgo = `vor ${hours}h`;
+        else if (minutes > 0) timeAgo = `vor ${minutes}m`;
+        else timeAgo = "gerade";
+      }
+      const num = String(i + 1).padStart(2, " ");
+      const name = project.name.padEnd(20);
+      const syncStatus = statusText.padEnd(8);
+      console.log(
+        `${colors.dim(num + ".")} ${name} ${statusIcon} ${colors.dim(syncStatus)} ${colors.dim(timeAgo)}`
+      );
+      if (options.verbose) {
+        log.dim(`    Pfad: ${project.path}`);
+        if (project.description) {
+          log.dim(`    ${project.description}`);
+        }
+      }
+    }
+    log.newline();
+    const config2 = getConfig();
+    const usagePercent = stats.projects.total / stats.projects.limit * 100;
+    if (usagePercent >= 80) {
+      log.warn(`Du nutzt ${Math.round(usagePercent)}% deines Projekt-Limits.`);
+      if (config2.tier === "free") {
+        log.info("Upgrade auf Pro f\xFCr mehr Projekte: https://shiva.li/pricing");
+      }
+    }
+  } catch (error) {
+    spinner.fail("Fehler beim Laden");
+    log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+  }
+});
+
+// src/commands/connect.ts
+import { Command as Command7 } from "commander";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5 } from "path";
+import ora4 from "ora";
+var connectCommand = new Command7("connect").description("Zwei Projekte verbinden").argument("<project>", "Pfad zum anderen Projekt oder Projekt-ID").option("-t, --type <type>", "Verbindungstyp (related, depends_on, child_of)", "related").option("-d, --dir <directory>", "Aktuelles Projektverzeichnis", ".").action(async (targetProject, options) => {
+  if (!isAuthenticated()) {
+    log.error('Nicht angemeldet. Bitte zuerst "shiva login" ausf\xFChren.');
+    return;
+  }
+  const currentDir = resolve5(options.dir);
+  if (!existsSync5(currentDir)) {
+    log.error(`Verzeichnis nicht gefunden: ${currentDir}`);
+    return;
+  }
+  const spinner = ora4("Projekte werden verbunden...").start();
+  try {
+    const currentScanned = await scanProject(currentDir);
+    let currentProject = await api.findProjectByPath(currentScanned.path);
+    if (!currentProject) {
+      spinner.fail("Aktuelles Projekt nicht in Cloud gefunden");
+      log.info('F\xFChre zuerst "shiva sync" aus.');
+      return;
+    }
+    let targetProjectObj;
+    const targetId = parseInt(targetProject, 10);
+    if (!isNaN(targetId)) {
+      targetProjectObj = await api.getProject(targetId);
+    } else {
+      const targetPath = resolve5(targetProject);
+      if (!existsSync5(targetPath)) {
+        spinner.fail(`Ziel-Verzeichnis nicht gefunden: ${targetPath}`);
+        return;
+      }
+      const targetScanned = await scanProject(targetPath);
+      targetProjectObj = await api.findProjectByPath(targetScanned.path);
+      if (!targetProjectObj) {
+        spinner.fail("Ziel-Projekt nicht in Cloud gefunden");
+        log.info(`F\xFChre zuerst "shiva sync" in ${targetPath} aus.`);
+        return;
+      }
+    }
+    if (currentProject.id === targetProjectObj.id) {
+      spinner.fail("Ein Projekt kann nicht mit sich selbst verbunden werden.");
+      return;
+    }
+    await api.connectProjects(currentProject.id, targetProjectObj.id, options.type);
+    spinner.succeed("Projekte verbunden");
+    log.newline();
+    log.success(`${currentProject.name} \u2194 ${targetProjectObj.name}`);
+    log.dim(`  Typ: ${options.type}`);
+  } catch (error) {
+    spinner.fail("Fehler beim Verbinden");
+    log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+  }
+});
+var disconnectCommand = new Command7("disconnect").description("Projekt-Verbindung trennen").argument("<project>", "Pfad zum anderen Projekt oder Projekt-ID").option("-d, --dir <directory>", "Aktuelles Projektverzeichnis", ".").action(async (targetProject, options) => {
+  if (!isAuthenticated()) {
+    log.error('Nicht angemeldet. Bitte zuerst "shiva login" ausf\xFChren.');
+    return;
+  }
+  const currentDir = resolve5(options.dir);
+  if (!existsSync5(currentDir)) {
+    log.error(`Verzeichnis nicht gefunden: ${currentDir}`);
+    return;
+  }
+  const spinner = ora4("Verbindung wird getrennt...").start();
+  try {
+    const currentScanned = await scanProject(currentDir);
+    const currentProject = await api.findProjectByPath(currentScanned.path);
+    if (!currentProject) {
+      spinner.fail("Aktuelles Projekt nicht in Cloud gefunden");
+      return;
+    }
+    let targetProjectObj;
+    const targetId = parseInt(targetProject, 10);
+    if (!isNaN(targetId)) {
+      targetProjectObj = await api.getProject(targetId);
+    } else {
+      const targetPath = resolve5(targetProject);
+      if (existsSync5(targetPath)) {
+        const targetScanned = await scanProject(targetPath);
+        targetProjectObj = await api.findProjectByPath(targetScanned.path);
+      }
+    }
+    if (!targetProjectObj) {
+      spinner.fail("Ziel-Projekt nicht gefunden");
+      return;
+    }
+    await api.disconnectProjects(currentProject.id, targetProjectObj.id);
+    spinner.succeed("Verbindung getrennt");
+  } catch (error) {
+    spinner.fail("Fehler beim Trennen");
+    log.error(error instanceof Error ? error.message : "Unbekannter Fehler");
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command8 } from "commander";
+var configCommand = new Command8("config").description("Konfiguration anzeigen oder \xE4ndern").argument("[key]", "Konfigurationsschl\xFCssel").argument("[value]", "Neuer Wert").option("-l, --list", "Alle Konfigurationswerte anzeigen").option("--reset", "Konfiguration zur\xFCcksetzen").action(async (key, value, options) => {
+  if (options.reset) {
+    clearConfig();
+    log.success("Konfiguration zur\xFCckgesetzt");
+    return;
+  }
+  const config2 = getConfig();
+  if (options.list || !key && !value) {
+    log.brand();
+    log.header("Konfiguration");
+    log.newline();
+    log.keyValue("Config Pfad", CONFIG_PATH);
+    log.newline();
+    log.keyValue("API Endpoint", config2.apiEndpoint || "https://shiva-ai-api.slither-mutiplayer.workers.dev");
+    log.keyValue("User", config2.email || colors.dim("nicht angemeldet"));
+    log.keyValue("User ID", config2.userId ? String(config2.userId) : colors.dim("-"));
+    log.keyValue("Tier", config2.tier?.toUpperCase() || "FREE");
+    const token = getToken();
+    if (token) {
+      const masked = token.slice(0, 8) + "..." + token.slice(-4);
+      log.keyValue("Token", masked);
+    } else {
+      log.keyValue("Token", colors.dim("nicht vorhanden"));
+    }
+    log.newline();
+    log.dim("Verwendung: shiva config <key> <value>");
+    log.dim("Beispiel: shiva config apiEndpoint https://custom.api.com");
+    return;
+  }
+  if (key && !value) {
+    const validKeys = ["apiEndpoint", "email", "userId", "tier", "token"];
+    if (!validKeys.includes(key)) {
+      log.error(`Unbekannter Schl\xFCssel: ${key}`);
+      log.info(`G\xFCltige Schl\xFCssel: ${validKeys.join(", ")}`);
+      return;
+    }
+    const configValue = key === "token" ? getToken() : config2[key];
+    if (configValue) {
+      if (key === "token") {
+        const masked = String(configValue).slice(0, 8) + "..." + String(configValue).slice(-4);
+        console.log(masked);
+      } else {
+        console.log(configValue);
+      }
+    } else {
+      log.dim("(nicht gesetzt)");
+    }
+    return;
+  }
+  if (key && value) {
+    const settableKeys = ["apiEndpoint"];
+    if (!settableKeys.includes(key)) {
+      log.error(`Schl\xFCssel "${key}" kann nicht manuell gesetzt werden`);
+      log.info("Setzbarer Schl\xFCssel: apiEndpoint");
+      log.dim('Andere Werte werden durch "shiva login" gesetzt.');
+      return;
+    }
+    if (key === "apiEndpoint") {
+      try {
+        new URL(value);
+      } catch {
+        log.error("Ung\xFCltige URL");
+        return;
+      }
+    }
+    setConfig(key, value);
+    log.success(`${key} aktualisiert`);
+    log.keyValue(key, value);
+  }
+});
+configCommand.command("get <key>").description("Konfigurationswert anzeigen").action((key) => {
+  const config2 = getConfig();
+  const validKeys = ["apiEndpoint", "email", "userId", "tier"];
+  if (!validKeys.includes(key)) {
+    log.error(`Unbekannter Schl\xFCssel: ${key}`);
+    return;
+  }
+  const value = config2[key];
+  if (value) {
+    console.log(value);
+  } else {
+    log.dim("(nicht gesetzt)");
+  }
+});
+configCommand.command("set <key> <value>").description("Konfigurationswert setzen").action((key, value) => {
+  const settableKeys = ["apiEndpoint"];
+  if (!settableKeys.includes(key)) {
+    log.error(`Schl\xFCssel "${key}" kann nicht manuell gesetzt werden`);
+    return;
+  }
+  if (key === "apiEndpoint") {
+    try {
+      new URL(value);
+    } catch {
+      log.error("Ung\xFCltige URL");
+      return;
+    }
+  }
+  setConfig(key, value);
+  log.success(`${key} aktualisiert`);
+});
+configCommand.command("reset").description("Konfiguration zur\xFCcksetzen").action(() => {
+  clearConfig();
+  log.success("Konfiguration zur\xFCckgesetzt");
+});
+
+// src/index.ts
+var program = new Command9();
+program.name("shiva").description("SHIVA Code - Makes Claude Code Persistent").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(initCommand);
+program.addCommand(syncCommand);
+program.addCommand(statusCommand);
+program.addCommand(projectsCommand);
+program.addCommand(connectCommand);
+program.addCommand(disconnectCommand);
+program.addCommand(configCommand);
+program.action(() => {
+  log.brand();
+  log.newline();
+  log.plain("Verf\xFCgbare Befehle:");
+  log.newline();
+  log.plain("  shiva login       Anmelden");
+  log.plain("  shiva logout      Abmelden");
+  log.plain("  shiva init        Projekt initialisieren");
+  log.plain("  shiva sync        Mit Cloud synchronisieren");
+  log.plain("  shiva status      Status anzeigen");
+  log.plain("  shiva projects    Alle Projekte auflisten");
+  log.plain("  shiva connect     Projekte verbinden");
+  log.plain("  shiva disconnect  Verbindung trennen");
+  log.plain("  shiva config      Konfiguration verwalten");
+  log.newline();
+  log.dim("Hilfe: shiva <befehl> --help");
+});
+program.exitOverride((err) => {
+  if (err.code === "commander.help") {
+    process.exit(0);
+  }
+  if (err.code === "commander.version") {
+    process.exit(0);
+  }
+  process.exit(1);
+});
+program.parse();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "shiva-code",
+  "version": "0.1.0",
+  "description": "Makes Claude Code Persistent - Cross-Project Memory CLI",
+  "author": "SHIVA AI",
+  "license": "MIT",
+  "bin": {
+    "shiva": "./dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "inquirer": "^12.3.0",
+    "open": "^10.1.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "memory",
+    "cli",
+    "shiva"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Aimtaim/shiva-code"
+  }
+}