@heysalad/cheri-cli 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# Cheri CLI
+
+AI-powered cloud IDE by [HeySalad](https://heysalad.app). Like Claude Code, but for cloud workspaces.
+
+## Install
+
+```bash
+npm install -g @heysalad/cheri-cli
+```
+
+## Usage
+
+```bash
+# Login to your Cheri account
+cheri login
+
+# Check account status
+cheri status
+
+# Launch a cloud workspace
+cheri workspace launch owner/repo
+
+# List your workspaces
+cheri workspace list
+
+# Stop a workspace
+cheri workspace stop
+
+# Initialize AI project config
+cheri init
+
+# Manage persistent memory
+cheri memory show
+cheri memory add "Always use TypeScript strict mode"
+cheri memory clear
+
+# View/update configuration
+cheri config list
+cheri config set apiUrl https://cheri.heysalad.app
+```
+
+## How it works
+
+1. **`cheri login`** opens your browser for GitHub OAuth, then you paste your API token
+2. **`cheri workspace launch`** spins up a cloud workspace with code-server (VS Code in browser)
+3. **`cheri memory`** stores persistent context that follows you across sessions
+4. **`cheri init`** creates a local `.ai/` directory with project constitution files
+
+## Requirements
+
+- Node.js >= 18
+
+## Links
+
+- [Cheri Cloud IDE](https://cheri.heysalad.app)
+- [GitHub](https://github.com/Hey-Salad/cheri-cli)
+
+## License
+
+MIT - HeySalad

package/bin/cheri.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { registerInitCommand } from "../src/commands/init.js";
+import { registerLoginCommand } from "../src/commands/login.js";
+import { registerStatusCommand } from "../src/commands/status.js";
+import { registerMemoryCommand } from "../src/commands/memory.js";
+import { registerConfigCommand } from "../src/commands/config.js";
+import { registerWorkspaceCommand } from "../src/commands/workspace.js";
+
+program
+  .name("cheri")
+  .description("Cheri CLI - AI-powered cloud IDE by HeySalad")
+  .version("0.1.0");
+
+registerLoginCommand(program);
+registerInitCommand(program);
+registerStatusCommand(program);
+registerMemoryCommand(program);
+registerConfigCommand(program);
+registerWorkspaceCommand(program);
+
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@heysalad/cheri-cli",
+  "version": "0.1.0",
+  "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
+  "type": "module",
+  "bin": {
+    "cheri": "./bin/cheri.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/cheri.js",
+    "dev": "node bin/cheri.js",
+    "release:patch": "npm version patch && npm publish --access public && git push && git push --tags",
+    "release:minor": "npm version minor && npm publish --access public && git push && git push --tags",
+    "release:major": "npm version major && npm publish --access public && git push && git push --tags"
+  },
+  "keywords": [
+    "cloud-ide",
+    "ai",
+    "code-server",
+    "workspace",
+    "cli",
+    "cheri",
+    "heysalad"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Hey-Salad/cheri-cli.git"
+  },
+  "homepage": "https://cheri.heysalad.app",
+  "author": "HeySalad",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.23",
+    "ora": "^8.0.1"
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+import { getConfig, getConfigValue, setConfigValue } from "../lib/config-store.js";
+import { log } from "../lib/logger.js";
+
+export function registerConfigCommand(program) {
+  const config = program
+    .command("config")
+    .description("Manage CLI configuration");
+
+  config
+    .command("list")
+    .description("Show all configuration values")
+    .action(() => {
+      const cfg = getConfig();
+
+      log.blank();
+      log.brand("Configuration");
+      log.blank();
+
+      printObject(cfg, "");
+      log.blank();
+    });
+
+  config
+    .command("get <key>")
+    .description("Get a configuration value")
+    .action((key) => {
+      const value = getConfigValue(key);
+      if (value === undefined) {
+        log.error(`Key '${key}' not found.`);
+        process.exit(1);
+      }
+      if (typeof value === "object") {
+        console.log(JSON.stringify(value, null, 2));
+      } else {
+        console.log(value);
+      }
+    });
+
+  config
+    .command("set <key> <value>")
+    .description("Set a configuration value")
+    .action((key, value) => {
+      // Try to parse as JSON (for arrays, numbers, booleans)
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        parsed = value;
+      }
+
+      setConfigValue(key, parsed);
+      log.success(`Set ${chalk.cyan(key)} = ${chalk.white(value)}`);
+    });
+}
+
+function printObject(obj, prefix) {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (key === "token" && value) {
+      console.log(`  ${chalk.dim(fullKey.padEnd(28))} ${chalk.dim("****" + String(value).slice(-8))}`);
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      console.log(`  ${chalk.dim(fullKey)}`);
+      printObject(value, fullKey);
+    } else if (Array.isArray(value)) {
+      console.log(`  ${chalk.dim(fullKey.padEnd(28))} ${chalk.white(value.join(", "))}`);
+    } else {
+      console.log(`  ${chalk.dim(fullKey.padEnd(28))} ${chalk.white(value)}`);
+    }
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,168 @@
+import ora from "ora";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { setConfigValue } from "../lib/config-store.js";
+import { log } from "../lib/logger.js";
+
+const AI_DIR = ".ai";
+
+const TEMPLATES = {
+  "style.md": `# Code Style Guide
+
+## Naming Conventions
+- camelCase for variables and functions
+- PascalCase for components and classes
+- UPPER_SNAKE_CASE for constants
+
+## TypeScript
+- Use strict mode
+- Prefer named exports over default exports
+- Use Zod for all validation schemas
+- Prefer interfaces over type aliases for object shapes
+
+## Formatting
+- 2 space indentation
+- Single quotes for strings
+- Trailing commas in multi-line expressions
+- Max line length: 100 characters
+`,
+
+  "architecture.md": `# Architecture
+
+## API Layer
+- Use Hono for all API routes
+- File-based routing organized by feature
+- Middleware-first pattern for auth, validation, logging
+
+## Data Layer
+- Repository pattern for all data access
+- Raw SQL queries (no ORMs)
+- Migrations tracked in /migrations
+
+## Frontend
+- React with functional components
+- Server components by default
+- Client components only when interactivity needed
+- Colocate styles with components
+
+## Deployment
+- Edge-first deployment strategy
+- Environment-based configuration
+- Feature flags for staged rollouts
+`,
+
+  "constraints.md": `# Constraints
+
+## Security
+- No secrets in environment variables at build time
+- All endpoints must have rate limiting
+- Input validation on every API endpoint
+- Parameterized queries only (no string interpolation in SQL)
+
+## Performance
+- Bundle size < 100KB (client-side)
+- API response time < 200ms (p95)
+- No N+1 queries
+
+## Dependencies
+- Minimize third-party dependencies
+- No client-side state management libraries
+- No CSS-in-JS runtime libraries
+- Audit all new dependencies before adding
+
+## Compatibility
+- Support latest 2 major browser versions
+- Node.js >= 20
+- Mobile-first responsive design
+`,
+};
+
+export function registerInitCommand(program) {
+  program
+    .command("init")
+    .description("Initialize a new Cheri project with AI constitution")
+    .option("-n, --name <name>", "Project name")
+    .option("-y, --yes", "Skip prompts and use defaults")
+    .action(async (options) => {
+      log.blank();
+      log.brand("Initializing project...");
+      log.blank();
+
+      const aiDir = join(process.cwd(), AI_DIR);
+
+      if (existsSync(aiDir) && !options.yes) {
+        const { overwrite } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: "A .ai/ directory already exists. Add missing files?",
+            default: true,
+          },
+        ]);
+        if (!overwrite) {
+          log.info("Initialization cancelled.");
+          return;
+        }
+      }
+
+      let projectName = options.name;
+      if (!projectName && !options.yes) {
+        const answers = await inquirer.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "Project name:",
+            default: process.cwd().split("/").pop(),
+          },
+        ]);
+        projectName = answers.name;
+      }
+
+      projectName = projectName || process.cwd().split("/").pop();
+
+      const spinner = ora("Creating project constitution...").start();
+
+      try {
+        if (!existsSync(aiDir)) {
+          mkdirSync(aiDir, { recursive: true });
+        }
+
+        const created = [];
+        for (const [filename, content] of Object.entries(TEMPLATES)) {
+          const filePath = join(aiDir, filename);
+          if (!existsSync(filePath)) {
+            writeFileSync(filePath, content);
+            created.push(filename);
+          }
+        }
+
+        spinner.succeed("Project constitution created");
+        log.blank();
+
+        if (created.length > 0) {
+          created.forEach((file) => {
+            console.log(`  ${chalk.green("+")} .ai/${file}`);
+          });
+        } else {
+          log.info("All constitution files already exist.");
+        }
+
+        // Save project config
+        setConfigValue("project.name", projectName);
+        setConfigValue("project.initializedAt", new Date().toISOString());
+
+        log.blank();
+        log.success(`Project '${chalk.bold(projectName)}' initialized.`);
+        log.dim(
+          `Run ${chalk.cyan("cheri workspace launch owner/repo")} to start coding in the cloud.`
+        );
+        log.blank();
+      } catch (err) {
+        spinner.fail("Failed to initialize project");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/login.js

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { setConfigValue, getConfigValue } from "../lib/config-store.js";
+import { apiClient } from "../lib/api-client.js";
+import { log } from "../lib/logger.js";
+
+export function registerLoginCommand(program) {
+  program
+    .command("login")
+    .description("Authenticate with Cheri cloud IDE")
+    .action(async () => {
+      const apiUrl = getConfigValue("apiUrl") || "https://cheri.heysalad.app";
+
+      log.blank();
+      log.brand("Login to Cheri");
+      log.blank();
+
+      log.info("Step 1: Open this URL in your browser to authenticate:");
+      log.blank();
+      console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/github`)}`);
+      log.blank();
+      log.info("Step 2: After login, visit the token page:");
+      console.log(`  ${chalk.cyan.underline(`${apiUrl}/auth/token?user=YOUR_USERNAME`)}`);
+      log.blank();
+      log.info("Step 3: Copy your API token and paste it below.");
+      log.blank();
+
+      const { token } = await inquirer.prompt([
+        {
+          type: "password",
+          name: "token",
+          message: "Paste your API token:",
+          mask: "*",
+        },
+      ]);
+
+      if (!token || !token.trim()) {
+        log.error("No token provided.");
+        process.exit(1);
+      }
+
+      setConfigValue("token", token.trim());
+
+      // Verify token works
+      try {
+        const me = await apiClient.getMe();
+        log.blank();
+        log.success(`Logged in as ${chalk.cyan(me.ghLogin || me.userId)}`);
+        log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
+        log.blank();
+      } catch (err) {
+        log.error(`Token verification failed: ${err.message}`);
+        setConfigValue("token", "");
+        process.exit(1);
+      }
+    });
+}

package/src/commands/memory.js

@@ -0,0 +1,127 @@
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync } from "fs";
+import { apiClient } from "../lib/api-client.js";
+import { log } from "../lib/logger.js";
+
+export function registerMemoryCommand(program) {
+  const memory = program
+    .command("memory")
+    .description("Manage AI context memory");
+
+  memory
+    .command("show")
+    .description("Show current memory entries")
+    .option("-l, --limit <n>", "Number of entries to show", "10")
+    .action(async (options) => {
+      const spinner = ora("Fetching memories...").start();
+
+      try {
+        const { memories } = await apiClient.getMemory();
+        spinner.stop();
+
+        log.blank();
+        log.brand("AI Memory");
+        log.blank();
+        log.keyValue("Entries", `${memories.length}`);
+
+        if (memories.length === 0) {
+          log.blank();
+          log.dim("  No memories yet. Use 'cheri memory add' to store context.");
+          log.blank();
+          return;
+        }
+
+        const limit = parseInt(options.limit);
+        const recent = memories.slice(-limit);
+
+        log.keyValue(
+          "Last updated",
+          memories.length > 0
+            ? timeSince(new Date(memories[memories.length - 1].timestamp))
+            : "never"
+        );
+
+        log.blank();
+        log.dim("  Recent memories:");
+
+        recent.forEach((entry) => {
+          const category = chalk.dim(`(${entry.category})`);
+          const content =
+            entry.content.length > 60
+              ? entry.content.slice(0, 60) + "..."
+              : entry.content;
+          console.log(`  ${chalk.dim("-")} "${content}" ${category}`);
+        });
+
+        log.blank();
+      } catch (err) {
+        spinner.fail("Failed to fetch memories");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  memory
+    .command("add")
+    .description("Add a memory entry")
+    .argument("<content>", "Memory content")
+    .option("-c, --category <category>", "Category", "general")
+    .action(async (content, options) => {
+      try {
+        const { entry, count } = await apiClient.addMemory(content, options.category);
+        log.success(`Memory saved (${count} total). Category: ${chalk.cyan(entry.category)}`);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  memory
+    .command("clear")
+    .description("Clear all memory")
+    .action(async () => {
+      try {
+        await apiClient.clearMemory();
+        log.success("All memories cleared.");
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  memory
+    .command("export")
+    .description("Export memory to JSON file")
+    .option("-o, --output <file>", "Output file path")
+    .action(async (options) => {
+      const spinner = ora("Exporting memories...").start();
+
+      try {
+        const { memories } = await apiClient.getMemory();
+
+        const exportData = {
+          version: "0.1.0",
+          exportedAt: new Date().toISOString(),
+          entryCount: memories.length,
+          entries: memories,
+        };
+
+        const outputFile = options.output || `cheri-memory-export.json`;
+        writeFileSync(outputFile, JSON.stringify(exportData, null, 2));
+        spinner.succeed(`Exported ${memories.length} entries to ${chalk.cyan(outputFile)}`);
+      } catch (err) {
+        spinner.fail("Failed to export memories");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+}
+
+function timeSince(date) {
+  const seconds = Math.floor((new Date() - date) / 1000);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)} min ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
+  return `${Math.floor(seconds / 86400)} days ago`;
+}

package/src/commands/status.js

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getConfigValue } from "../lib/config-store.js";
+import { apiClient } from "../lib/api-client.js";
+import { log } from "../lib/logger.js";
+
+export function registerStatusCommand(program) {
+  program
+    .command("status")
+    .description("Show account and workspace status")
+    .action(async () => {
+      log.blank();
+      log.brand("Status");
+
+      // Account info
+      log.header("Account");
+      const spinner = ora("Fetching account info...").start();
+
+      try {
+        const me = await apiClient.getMe();
+        spinner.stop();
+
+        log.keyValue("User", chalk.cyan(me.ghLogin || me.userId));
+        log.keyValue("Plan", me.plan === "pro" ? chalk.green("Pro") : "Free");
+      } catch (err) {
+        spinner.stop();
+        log.keyValue("User", chalk.yellow("Not logged in"));
+        log.dim(`  Run ${chalk.cyan("cheri login")} to authenticate.`);
+      }
+
+      // Workspaces
+      log.header("Workspaces");
+      try {
+        const { workspaces } = await apiClient.listWorkspaces();
+        if (workspaces.length === 0) {
+          log.keyValue("Count", "0");
+          log.dim(`  Run ${chalk.cyan("cheri workspace launch owner/repo")} to create one.`);
+        } else {
+          log.keyValue("Count", `${workspaces.length}`);
+          workspaces.forEach((ws) => {
+            const statusColor = ws.status === "running" ? chalk.green : chalk.dim;
+            console.log(`    ${statusColor("●")} ${ws.id} (${ws.repo || ws.id}) — ${statusColor(ws.status)}`);
+          });
+        }
+      } catch {
+        log.dim("  Could not fetch workspaces.");
+      }
+
+      // Config info
+      log.header("Configuration");
+      log.keyValue("API URL", getConfigValue("apiUrl") || "https://cheri.heysalad.app");
+      log.keyValue("Config dir", chalk.dim("~/.cheri/"));
+
+      log.blank();
+    });
+}

package/src/commands/workspace.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import ora from "ora";
+import { apiClient } from "../lib/api-client.js";
+import { log } from "../lib/logger.js";
+
+export function registerWorkspaceCommand(program) {
+  const workspace = program
+    .command("workspace")
+    .description("Manage cloud workspaces");
+
+  workspace
+    .command("launch")
+    .description("Launch a new cloud workspace")
+    .argument("<repo>", "GitHub repository (owner/repo)")
+    .action(async (repo) => {
+      log.blank();
+      log.brand("Launching workspace");
+      log.blank();
+
+      const spinner = ora("Creating workspace...").start();
+
+      try {
+        const { workspace: ws } = await apiClient.createWorkspace(repo);
+        spinner.succeed("Workspace is live!");
+
+        log.blank();
+        log.keyValue("ID", chalk.cyan(ws.id));
+        log.keyValue("Repo", chalk.cyan(ws.repo));
+        log.keyValue("Status", chalk.green(ws.status));
+        log.keyValue("URL", chalk.cyan.underline(ws.url));
+        log.blank();
+        log.dim("Open the URL above in your browser to start coding.");
+        log.blank();
+      } catch (err) {
+        spinner.fail("Failed to launch workspace");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  workspace
+    .command("stop")
+    .description("Stop a running workspace")
+    .argument("<id>", "Workspace ID")
+    .action(async (id) => {
+      const spinner = ora(`Stopping workspace: ${id}...`).start();
+
+      try {
+        await apiClient.deleteWorkspace(id);
+        spinner.succeed(`Workspace '${chalk.cyan(id)}' stopped.`);
+        log.dim("  Data preserved. Launch again to resume.");
+      } catch (err) {
+        spinner.fail("Failed to stop workspace");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  workspace
+    .command("list")
+    .description("List all workspaces")
+    .action(async () => {
+      const spinner = ora("Fetching workspaces...").start();
+
+      try {
+        const { workspaces } = await apiClient.listWorkspaces();
+        spinner.stop();
+
+        log.blank();
+        log.brand("Workspaces");
+        log.blank();
+
+        if (workspaces.length === 0) {
+          log.dim("  No workspaces found. Run 'cheri workspace launch owner/repo' to create one.");
+          log.blank();
+          return;
+        }
+
+        // Table header
+        console.log(
+          `  ${chalk.dim("ID".padEnd(24))} ${chalk.dim("REPO".padEnd(24))} ${chalk.dim("STATUS".padEnd(10))} ${chalk.dim("URL")}`
+        );
+        console.log(chalk.dim("  " + "-".repeat(90)));
+
+        workspaces.forEach((ws) => {
+          const statusColor =
+            ws.status === "running" ? chalk.green : chalk.dim;
+          console.log(
+            `  ${ws.id.padEnd(24)} ${(ws.repo || "").padEnd(24)} ${statusColor(ws.status.padEnd(10))} ${chalk.cyan(ws.url || "")}`
+          );
+        });
+
+        log.blank();
+      } catch (err) {
+        spinner.fail("Failed to fetch workspaces");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  workspace
+    .command("status")
+    .description("Get workspace status")
+    .argument("<id>", "Workspace ID")
+    .action(async (id) => {
+      const spinner = ora("Fetching workspace status...").start();
+
+      try {
+        const { workspace: ws } = await apiClient.getWorkspaceStatus(id);
+        spinner.stop();
+
+        log.blank();
+        log.brand(`Workspace: ${ws.id}`);
+        log.blank();
+        log.keyValue("Status", ws.status === "running" ? chalk.green(ws.status) : chalk.dim(ws.status));
+        log.keyValue("Repo", chalk.cyan(ws.repo || ""));
+        log.keyValue("URL", chalk.cyan.underline(ws.url || ""));
+        log.keyValue("Created", new Date(ws.createdAt).toLocaleString());
+        log.blank();
+      } catch (err) {
+        spinner.fail("Failed to fetch workspace status");
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+}

package/src/lib/api-client.js

@@ -0,0 +1,86 @@
+import { getConfigValue } from "./config-store.js";
+
+function getBaseUrl() {
+  return getConfigValue("apiUrl") || "https://cheri.heysalad.app";
+}
+
+function getToken() {
+  return getConfigValue("token") || "";
+}
+
+async function request(path, options = {}) {
+  const baseUrl = getBaseUrl();
+  const token = getToken();
+
+  if (!token) {
+    throw new Error("Not logged in. Run 'cheri login' first.");
+  }
+
+  const url = `${baseUrl}${path}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    let msg;
+    try {
+      msg = JSON.parse(body).error || body;
+    } catch {
+      msg = body;
+    }
+    throw new Error(`API error (${res.status}): ${msg}`);
+  }
+
+  return res.json();
+}
+
+export const apiClient = {
+  // Auth
+  async getMe() {
+    return request("/api/me");
+  },
+
+  // Workspaces
+  async listWorkspaces() {
+    return request("/api/workspaces");
+  },
+
+  async createWorkspace(repo) {
+    return request("/api/workspaces", {
+      method: "POST",
+      body: JSON.stringify({ repo }),
+    });
+  },
+
+  async deleteWorkspace(id) {
+    return request(`/api/workspaces/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    });
+  },
+
+  async getWorkspaceStatus(id) {
+    return request(`/api/workspaces/${encodeURIComponent(id)}/status`);
+  },
+
+  // Memory
+  async getMemory() {
+    return request("/api/memory");
+  },
+
+  async addMemory(content, category = "general") {
+    return request("/api/memory", {
+      method: "POST",
+      body: JSON.stringify({ content, category }),
+    });
+  },
+
+  async clearMemory() {
+    return request("/api/memory", { method: "DELETE" });
+  },
+};

package/src/lib/config-store.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const CONFIG_DIR = join(homedir(), ".cheri");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function getConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return getDefaultConfig();
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return getDefaultConfig();
+  }
+}
+
+export function setConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getConfigValue(key) {
+  const config = getConfig();
+  return key.split(".").reduce((obj, k) => obj?.[k], config);
+}
+
+export function setConfigValue(key, value) {
+  const config = getConfig();
+  const keys = key.split(".");
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!current[keys[i]] || typeof current[keys[i]] !== "object") {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+  setConfig(config);
+}
+
+function getDefaultConfig() {
+  return {
+    apiUrl: "https://cheri.heysalad.app",
+    token: "",
+    workspace: {
+      defaultResources: {
+        cpu: 2,
+        ram: "4GB",
+        disk: "10GB",
+      },
+      idleTimeout: 600,
+    },
+    sync: {
+      ignore: [
+        "node_modules",
+        ".git",
+        ".next",
+        "dist",
+        ".env",
+        ".env.local",
+      ],
+      debounce: 300,
+    },
+    editor: {
+      theme: "dark",
+      fontSize: 14,
+    },
+  };
+}

package/src/lib/logger.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+
+export const log = {
+  info(msg) {
+    console.log(chalk.blue("info") + "  " + msg);
+  },
+  success(msg) {
+    console.log(chalk.green("done") + "  " + msg);
+  },
+  warn(msg) {
+    console.log(chalk.yellow("warn") + "  " + msg);
+  },
+  error(msg) {
+    console.log(chalk.red("error") + " " + msg);
+  },
+  dim(msg) {
+    console.log(chalk.dim(msg));
+  },
+  brand(msg) {
+    console.log(chalk.red.bold("cheri") + " " + msg);
+  },
+  blank() {
+    console.log();
+  },
+  header(title) {
+    console.log();
+    console.log(chalk.bold(title));
+    console.log(chalk.dim("─".repeat(title.length)));
+  },
+  keyValue(key, value) {
+    console.log(`  ${chalk.dim(key.padEnd(16))} ${value}`);
+  },
+  tree(items) {
+    items.forEach((item, i) => {
+      const prefix = i === items.length - 1 ? "  └─" : "  ├─";
+      console.log(chalk.dim(prefix) + " " + item);
+    });
+  },
+};