lecodes-cli 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# lecodes-cli
+
+Clone, edit and push [LeCodes](https://le.codes) projects from your machine, with full TypeScript
+IntelliSense for the platform API in your editor.
+
+The package is `lecodes-cli`; the command it installs is **`lecodes`**.
+
+## Install
+
+```sh
+npm i -g lecodes-cli      # then run: lecodes <command>
+# or without installing:
+npx lecodes-cli <command>
+```
+
+## Quick start
+
+```sh
+lecodes login                       # paste a token, or sign in with email/password
+lecodes clone <project-uuid> myapp  # download files + types into ./myapp
+cd myapp
+#   …edit files in VS Code (IntelliSense works out of the box)…
+lecodes status                      # see what changed
+lecodes push -m "Tweak the menu"    # push as a new checkpoint
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `login` | Store a personal access token in `~/.lecodes/config.json`. `--token <pat>` to use a token created in the web UI, `--api <url>` to set the server. |
+| `clone <uuid\|url> [dir]` | Download a project's file tree + binary resources, plus `.d.ts` types and a `tsconfig.json` for IntelliSense. `--no-types` to skip types. |
+| `status` | Show added / modified / moved / deleted files vs the last sync. |
+| `pull` | Overwrite local files with the project's current remote state. `--force` to discard local edits. |
+| `push` | Push all local changes as **one** new checkpoint. `-m`/`--message` for the message, `--force` to override the "server moved on" guard. |
+
+## How it works
+
+- Project metadata and the path → asset map live in `.lecodes/` (commit it or not — it's like `.git`).
+- A **push** sends your whole working tree to the server, which atomically rebuilds the project's
+  file tree (adds, edits, deletes, renames and moves all at once) and freezes a single checkpoint.
+  Renames/moves keep their history; unchanged binaries are never re-uploaded.
+- Types are fetched from the server on `clone`/`pull`, so they always match the deployed runtime.
+
+Config can also be supplied via the `LECODES_API` and `LECODES_TOKEN` environment variables (useful in CI).

package/dist/index.js

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+
+// src/commands/clone.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+// src/util.ts
+import { createHash } from "node:crypto";
+import { createInterface } from "node:readline";
+var useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined;
+var paint = (code, s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = {
+  bold: (s) => paint("1", s),
+  dim: (s) => paint("2", s),
+  red: (s) => paint("31", s),
+  green: (s) => paint("32", s),
+  yellow: (s) => paint("33", s),
+  cyan: (s) => paint("36", s)
+};
+var log = (msg = "") => process.stdout.write(msg + `
+`);
+var info = (msg) => log(msg);
+var success = (msg) => log(c.green("✓ ") + msg);
+class CliError extends Error {
+}
+var sha256 = (data) => createHash("sha256").update(data).digest("hex");
+var toKey = (path) => {
+  const parts = path.replace(/\\/g, "/").split("/").map((p) => p.trim()).filter((p) => p && p !== ".");
+  if (parts.some((p) => p === ".."))
+    throw new CliError(`Unsafe path: ${path}`);
+  return "/" + parts.join("/");
+};
+var prompt = (question, fallback) => new Promise((resolve) => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const suffix = fallback ? c.dim(` (${fallback})`) : "";
+  rl.question(`${question}${suffix}: `, (answer) => {
+    rl.close();
+    resolve(answer.trim() || fallback || "");
+  });
+});
+var promptHidden = (question) => new Promise((resolve) => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  rl.question(`${question}: `, (answer) => {
+    rl.close();
+    process.stdout.write(`
+`);
+    resolve(answer.trim());
+  });
+  rl._writeToOutput = () => {};
+});
+var parseArgs = (argv) => {
+  const out = { _: [], flags: {} };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq >= 0) {
+        out.flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+        continue;
+      }
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        out.flags[key] = next;
+        i++;
+      } else
+        out.flags[key] = true;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const key = arg.slice(1);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        out.flags[key] = next;
+        i++;
+      } else
+        out.flags[key] = true;
+    } else {
+      out._.push(arg);
+    }
+  }
+  return out;
+};
+var flagStr = (args, ...keys) => {
+  for (const key of keys) {
+    const v = args.flags[key];
+    if (typeof v === "string")
+      return v;
+  }
+  return;
+};
+var flagBool = (args, ...keys) => keys.some((key) => args.flags[key] === true || args.flags[key] === "true");
+
+// src/api.ts
+var errorMessage = (body, status) => {
+  if (typeof body === "string" && body)
+    return body;
+  if (body && typeof body === "object") {
+    const b = body;
+    if (typeof b.error === "string")
+      return b.error;
+    if (b.error && typeof b.error === "object") {
+      const first = Object.values(b.error)[0];
+      if (typeof first === "string")
+        return first;
+      if (first && typeof first === "object" && typeof first.message === "string") {
+        return first.message;
+      }
+    }
+    if (typeof b.message === "string")
+      return b.message;
+  }
+  return `Request failed with status ${status}`;
+};
+var apiRequest = async (apiUrl, path, opts = {}) => {
+  const headers = {};
+  const isForm = opts.body instanceof FormData;
+  if (opts.token)
+    headers["Authorization"] = "Bearer " + opts.token;
+  if (opts.body !== undefined && !isForm)
+    headers["Content-Type"] = "application/json";
+  let resp;
+  try {
+    resp = await fetch(`${apiUrl}/api${path}`, {
+      method: opts.method ?? (opts.body !== undefined ? "POST" : "GET"),
+      headers,
+      body: opts.body === undefined ? undefined : isForm ? opts.body : JSON.stringify(opts.body)
+    });
+  } catch (e) {
+    throw new CliError(`Cannot reach ${apiUrl} — is the server URL correct and online?`);
+  }
+  const contentType = resp.headers.get("content-type") ?? "";
+  const parsed = contentType.startsWith("application/json") ? await resp.json() : contentType.startsWith("text/") ? await resp.text() : null;
+  if (resp.status >= 400)
+    throw new CliError(errorMessage(parsed, resp.status));
+  return parsed;
+};
+var login = (apiUrl, login2, password) => apiRequest(apiUrl, "/account/login", { body: { login: login2, password } });
+var createAccessToken = (apiUrl, jwt, name) => apiRequest(apiUrl, "/account/tokens", { token: jwt, body: { name } });
+var getAccount = (apiUrl, token) => apiRequest(apiUrl, "/account", { token });
+var getProject = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}`, { token });
+var getCommits = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}/commits`, { token });
+var getTypes = (apiUrl) => apiRequest(apiUrl, "/types");
+var uploadBlob = (apiUrl, token, uuid, name, bytes) => {
+  const form = new FormData;
+  form.append("file", new Blob([bytes]), name);
+  return apiRequest(apiUrl, `/projects/${uuid}/blobs`, { token, body: form });
+};
+var sync = (apiUrl, token, uuid, payload) => apiRequest(apiUrl, `/projects/${uuid}/sync`, { token, body: payload });
+var downloadBlob = async (apiUrl, src) => {
+  const resp = await fetch(`${apiUrl}${src}`);
+  if (!resp.ok)
+    throw new CliError(`Failed to download ${src} (status ${resp.status})`);
+  return new Uint8Array(await resp.arrayBuffer());
+};
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+var DEFAULT_API = "https://le.codes";
+var CONFIG_DIR = join(homedir(), ".lecodes");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var loadConfig = () => {
+  let stored = {};
+  try {
+    stored = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+  } catch {}
+  return {
+    apiUrl: process.env.LECODES_API ?? stored.apiUrl,
+    token: process.env.LECODES_TOKEN ?? stored.token
+  };
+};
+var saveConfig = (config) => {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+};
+var normalizeApiUrl = (url) => url.trim().replace(/\/+$/, "");
+var requireToken = (config) => {
+  if (!config.token)
+    throw new CliError("Not logged in. Run `lecodes login` first.");
+  return config.token;
+};
+var requireApiUrl = (config) => {
+  if (!config.apiUrl)
+    throw new CliError("No server URL configured. Run `lecodes login` first.");
+  return normalizeApiUrl(config.apiUrl);
+};
+
+// src/manifest.ts
+import { dirname, join as join2 } from "node:path";
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+var LECODES_DIR = ".lecodes";
+var manifestPath = (root) => join2(root, LECODES_DIR, "manifest.json");
+var findProjectRoot = (start) => {
+  let dir = start;
+  while (true) {
+    if (existsSync(manifestPath(dir)))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      throw new CliError("Not inside a lecodes project (no .lecodes/manifest.json found).");
+    dir = parent;
+  }
+};
+var readManifest = (root) => {
+  try {
+    return JSON.parse(readFileSync2(manifestPath(root), "utf8"));
+  } catch {
+    throw new CliError("Could not read .lecodes/manifest.json — is this a lecodes project?");
+  }
+};
+var writeManifest = (root, manifest) => {
+  mkdirSync2(join2(root, LECODES_DIR), { recursive: true });
+  writeFileSync2(manifestPath(root), JSON.stringify(manifest, null, 2));
+};
+
+// src/project.ts
+import { dirname as dirname2, join as join3 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+var kindOf = (type) => type === "file" ? "resource" : type;
+var absOf = (root, key) => join3(root, ...key.replace(/^\//, "").split("/"));
+var buildPaths = (assets) => {
+  const pathById = new Map;
+  for (const asset of assets) {
+    const parent = asset.parentId !== null ? pathById.get(asset.parentId) : undefined;
+    pathById.set(asset.id, `${parent ?? ""}/${asset.name}`);
+  }
+  return pathById;
+};
+var materializeAssets = async (root, project, apiUrl, token) => {
+  const pathById = buildPaths(project.assets);
+  const files = {};
+  for (const asset of project.assets) {
+    const key = pathById.get(asset.id);
+    const abs = absOf(root, key);
+    if (asset.type === "folder") {
+      mkdirSync3(abs, { recursive: true });
+      continue;
+    }
+    mkdirSync3(dirname2(abs), { recursive: true });
+    let sha;
+    if (asset.type === "file") {
+      if (!asset.file?.src)
+        continue;
+      const bytes = await downloadBlob(apiUrl, asset.file.src);
+      writeFileSync3(abs, bytes);
+      sha = sha256(bytes);
+    } else {
+      const text = asset.text ?? "";
+      writeFileSync3(abs, text);
+      sha = sha256(text);
+    }
+    files[key] = { id: asset.id, type: kindOf(asset.type), sha };
+  }
+  return files;
+};
+
+// src/types.ts
+import { join as join4 } from "node:path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+var wrapGlobal = (text) => {
+  const marker = text.indexOf("declare global");
+  if (marker < 0)
+    return text;
+  const importLines = [];
+  const bodyLines = [];
+  for (const line of text.split(`
+`)) {
+    if (/^\s*import\s.*\sfrom\s/.test(line))
+      importLines.push(line);
+    else
+      bodyLines.push(line);
+  }
+  const rest = bodyLines.join(`
+`);
+  const open = rest.indexOf("{", rest.indexOf("declare global"));
+  const close = rest.lastIndexOf("}");
+  const preamble = rest.slice(0, rest.indexOf("declare global"));
+  const inner = rest.slice(open + 1, close);
+  const stripDeclare = (s) => s.replace(/(^|\n)([ \t]*)declare\s+/g, "$1$2");
+  const merged = stripDeclare(preamble) + `
+` + stripDeclare(inner);
+  return `${importLines.join(`
+`)}
+
+declare global {
+${merged}
+}
+`;
+};
+var TSCONFIG = {
+  compilerOptions: {
+    target: "ES2020",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    lib: ["ES2020"],
+    types: [],
+    allowJs: true,
+    checkJs: false,
+    strict: false,
+    noEmit: true,
+    skipLibCheck: true
+  },
+  include: [`${LECODES_DIR}/types/**/*.d.ts`, "**/*.ts", "**/*.js"],
+  exclude: ["node_modules"]
+};
+var materializeTypes = async (root, apiUrl) => {
+  const bundle = await getTypes(apiUrl);
+  const typesDir = join4(root, LECODES_DIR, "types");
+  mkdirSync4(typesDir, { recursive: true });
+  for (const [name, text] of Object.entries(bundle)) {
+    const content = name === "global" ? wrapGlobal(text) : text;
+    writeFileSync4(join4(typesDir, `${name}.d.ts`), content);
+  }
+};
+var writeTsconfig = (root) => {
+  writeFileSync4(join4(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+};
+
+// src/commands/clone.ts
+var parseUuid = (input) => {
+  if (!input)
+    throw new CliError("Usage: lecodes clone <project-uuid|url> [directory]");
+  if (!input.includes("/"))
+    return input;
+  const noQuery = input.split(/[?#]/)[0].replace(/\/+$/, "");
+  return noQuery.slice(noQuery.lastIndexOf("/") + 1);
+};
+var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+var clone = async (args) => {
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const uuid = parseUuid(args._[0]);
+  info(c.dim(`Fetching project ${uuid}…`));
+  const project = await getProject(apiUrl, token, uuid);
+  const dir = args._[1] ?? slug(project.name);
+  const root = resolve(dir);
+  if (existsSync2(root) && readdirSync(root).length > 0) {
+    throw new CliError(`Directory "${dir}" already exists and is not empty.`);
+  }
+  mkdirSync5(root, { recursive: true });
+  info(c.dim(`Writing ${project.assets.filter((a) => a.type !== "folder").length} files…`));
+  const files = await materializeAssets(root, project, apiUrl, token);
+  if (!flagBool(args, "no-types")) {
+    info(c.dim("Fetching type definitions…"));
+    await materializeTypes(root, apiUrl);
+    writeTsconfig(root);
+  }
+  const commits = await getCommits(apiUrl, token, uuid);
+  writeManifest(root, { uuid, apiUrl, name: project.name, baseHeadId: commits.headId, files });
+  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/`);
+  info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
+};
+
+// src/commands/login.ts
+import { hostname } from "node:os";
+var login2 = async (args) => {
+  const config = loadConfig();
+  const apiUrl = normalizeApiUrl(flagStr(args, "api") ?? await prompt("Server URL", config.apiUrl ?? DEFAULT_API));
+  let token = flagStr(args, "token");
+  if (!token) {
+    const email = flagStr(args, "email") ?? await prompt("Email");
+    const password = await promptHidden("Password");
+    info(c.dim("Authenticating…"));
+    const { accessToken } = await login(apiUrl, email, password);
+    const created = await createAccessToken(apiUrl, accessToken, `lecodes CLI (${hostname()})`);
+    token = created.token;
+  }
+  const account = await getAccount(apiUrl, token);
+  saveConfig({ apiUrl, token });
+  success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`);
+};
+
+// src/commands/pull.ts
+import { existsSync as existsSync3, rmSync } from "node:fs";
+import { join as join6 } from "node:path";
+
+// src/localFiles.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join5, relative } from "node:path";
+var SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
+var SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".DS_Store"]);
+var TEXT_EXTS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "svg",
+  "glsl",
+  "vert",
+  "frag",
+  "txt",
+  "md",
+  "css",
+  "html",
+  "xml",
+  "yml",
+  "yaml",
+  "csv"
+]);
+var ext = (name) => {
+  const i = name.lastIndexOf(".");
+  return i < 0 ? "" : name.slice(i + 1).toLowerCase();
+};
+var classifyKind = (name) => {
+  const e = ext(name);
+  if (e === "mat")
+    return "shader";
+  if (e === "scene")
+    return "scene";
+  return TEXT_EXTS.has(e) ? "text" : "resource";
+};
+var isTextKind = (kind) => kind !== "resource";
+var scanLocal = (root) => {
+  const files = [];
+  const dirs = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name))
+          continue;
+        const abs = join5(dir, entry.name);
+        dirs.push(toKey(relative(root, abs)));
+        walk(abs);
+      } else if (entry.isFile()) {
+        if (SKIP_FILES.has(entry.name))
+          continue;
+        const abs = join5(dir, entry.name);
+        const bytes = readFileSync3(abs);
+        files.push({ path: toKey(relative(root, abs)), absPath: abs, sha: sha256(bytes) });
+      }
+    }
+  };
+  walk(root);
+  return { files, dirs };
+};
+var diffLocal = (manifest, scan) => {
+  const added = [];
+  const modified = [];
+  const localByPath = new Map(scan.files.map((f) => [f.path, f]));
+  for (const file of scan.files) {
+    const known = manifest.files[file.path];
+    if (!known)
+      added.push(file);
+    else if (known.sha !== file.sha)
+      modified.push(file);
+  }
+  const deleted = Object.keys(manifest.files).filter((path) => !localByPath.has(path));
+  const moves = new Map;
+  const claimed = new Set;
+  for (const file of added) {
+    const from = deleted.find((path) => !claimed.has(path) && manifest.files[path].sha === file.sha);
+    if (from) {
+      moves.set(file.path, from);
+      claimed.add(from);
+    }
+  }
+  return { added, modified, deleted, moves };
+};
+var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
+
+// src/commands/pull.ts
+var pull = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  if (!flagBool(args, "force") && hasChanges(diffLocal(manifest, scanLocal(root)))) {
+    throw new CliError("You have local changes. Push them first, or run `lecodes pull --force` to discard them.");
+  }
+  info(c.dim("Fetching project…"));
+  const project = await getProject(apiUrl, token, manifest.uuid);
+  const remotePaths = new Set([...buildPaths(project.assets).entries()].filter(([id]) => project.assets.find((a) => a.id === id)?.type !== "folder").map(([, path]) => path));
+  for (const path of Object.keys(manifest.files)) {
+    if (!remotePaths.has(path)) {
+      const abs = join6(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync3(abs))
+        rmSync(abs);
+    }
+  }
+  const files = await materializeAssets(root, project, apiUrl, token);
+  if (!flagBool(args, "no-types")) {
+    await materializeTypes(root, apiUrl);
+    writeTsconfig(root);
+  }
+  const commits = await getCommits(apiUrl, token, manifest.uuid);
+  writeManifest(root, { ...manifest, name: project.name, baseHeadId: commits.headId, files });
+  success(`Pulled latest into ${c.bold(manifest.name)}.`);
+};
+
+// src/commands/push.ts
+import { basename } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+var push = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const scan = scanLocal(root);
+  const diff = diffLocal(manifest, scan);
+  if (!hasChanges(diff)) {
+    info(c.dim("Working tree clean — nothing to push."));
+    return;
+  }
+  if (!flagBool(args, "force") && manifest.baseHeadId !== null) {
+    const commits = await getCommits(apiUrl, token, manifest.uuid);
+    if (commits.headId !== manifest.baseHeadId) {
+      throw new CliError("The project changed on the server since your last sync. Run `lecodes pull` first, or `lecodes push --force` to overwrite.");
+    }
+  }
+  const message = (flagStr(args, "m", "message") ?? await prompt("Checkpoint message")) || "Update from lecodes CLI";
+  const sourceFor = (path) => manifest.files[path] ?? (diff.moves.has(path) ? manifest.files[diff.moves.get(path)] : undefined);
+  const files = [];
+  let uploaded = 0;
+  for (const file of scan.files) {
+    const source = sourceFor(file.path);
+    const kind = source?.type ?? classifyKind(basename(file.path));
+    const entry = { path: file.path, type: kind };
+    if (source)
+      entry.assetId = source.id;
+    if (isTextKind(kind)) {
+      entry.text = readFileSync4(file.absPath, "utf8");
+    } else if (!source || source.sha !== file.sha) {
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename(file.path), readFileSync4(file.absPath));
+      entry.blobFileId = blob.id;
+      uploaded++;
+    }
+    files.push(entry);
+  }
+  const folders = scan.dirs.map((path) => ({ path }));
+  if (uploaded > 0)
+    info(c.dim(`Uploaded ${uploaded} binary file${uploaded === 1 ? "" : "s"}.`));
+  const res = await sync(apiUrl, token, manifest.uuid, { message, files, folders });
+  if (!res.created) {
+    info(c.dim("Server reported no changes."));
+    return;
+  }
+  const shaByPath = new Map(scan.files.map((f) => [f.path, f.sha]));
+  const newFiles = {};
+  for (const node of res.nodes) {
+    newFiles[node.path] = { id: node.id, type: node.type, sha: shaByPath.get(node.path) ?? "" };
+  }
+  writeManifest(root, { ...manifest, baseHeadId: res.headId, files: newFiles });
+  const counts = [
+    diff.added.length - diff.moves.size && `${diff.added.length - diff.moves.size} added`,
+    diff.modified.length && `${diff.modified.length} modified`,
+    diff.moves.size && `${diff.moves.size} moved`,
+    diff.deleted.length - diff.moves.size && `${diff.deleted.length - diff.moves.size} deleted`
+  ].filter(Boolean).join(", ");
+  success(`Pushed checkpoint${res.seq ? ` #${res.seq}` : ""}${counts ? ` (${counts})` : ""}: ${message}`);
+};
+
+// src/commands/status.ts
+var status = async (_args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const diff = diffLocal(manifest, scanLocal(root));
+  info(`Project ${c.bold(manifest.name)} (${manifest.uuid})`);
+  if (!hasChanges(diff)) {
+    info(c.dim("Working tree clean — nothing to push."));
+    return;
+  }
+  for (const f of diff.added) {
+    if (!diff.moves.has(f.path))
+      log(c.green(`  added     ${f.path}`));
+  }
+  for (const f of diff.modified)
+    log(c.yellow(`  modified  ${f.path}`));
+  for (const [to, from] of diff.moves)
+    log(c.cyan(`  moved     ${from} → ${to}`));
+  const movedFrom = new Set(diff.moves.values());
+  for (const path of diff.deleted) {
+    if (!movedFrom.has(path))
+      log(c.red(`  deleted   ${path}`));
+  }
+};
+
+// src/index.ts
+var HELP = `${c.bold("lecodes")} — clone, edit and push LeCodes projects from your machine.
+
+${c.bold("Usage:")} lecodes <command> [options]
+
+${c.bold("Commands:")}
+  login                         Store a personal access token (prompts email/password)
+                                  --token <pat>   use an existing token instead
+                                  --api <url>     set the server URL
+  clone <uuid|url> [dir]        Download a project's files + types into a new folder
+                                  --no-types      skip the .d.ts / tsconfig generation
+  status                        Show local changes vs the last sync
+  pull                          Overwrite local files with the project's current state
+                                  --force         discard uncommitted local changes
+  push                          Push local changes as one new checkpoint
+                                  -m, --message   checkpoint message
+                                  --force         push even if the server moved on
+
+Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
+var commands = { login: login2, clone, status, pull, push };
+var main = async () => {
+  const argv = process.argv.slice(2);
+  const command = argv[0];
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    log(HELP);
+    return;
+  }
+  const run = commands[command];
+  if (!run) {
+    log(c.red(`Unknown command: ${command}`));
+    log(HELP);
+    process.exitCode = 1;
+    return;
+  }
+  await run(parseArgs(argv.slice(1)));
+};
+main().catch((e) => {
+  if (e instanceof CliError)
+    log(c.red("✗ ") + e.message);
+  else
+    log(c.red("✗ Unexpected error: ") + (e instanceof Error ? e.message : String(e)));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "lecodes-cli",
+  "version": "0.1.0",
+  "description": "Clone, edit and push LeCodes projects from your machine.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "lecodes",
+    "cli"
+  ],
+  "bin": {
+    "lecodes": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --target=node --outfile dist/index.js --banner=\"#!/usr/bin/env node\"",
+    "typecheck": "tsc --noEmit",
+    "dev": "bun run src/index.ts",
+    "prepublishOnly": "bun run build"
+  }
+}