lecodes-cli 0.19.0 → 0.20.0

package/src/commands/pull.ts

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { downloadBlob, getCommits, getProject, type Project, type ProjectAsset } from "../api"
+import { loadConfig, requireApiUrl, requireToken } from "../config"
+import { findProjectRoot, readManifest, writeManifest, type FileKind } from "../manifest"
+import { buildPaths, materializeAssets } from "../project"
+import { materializeTypes, writeTsconfig } from "../types"
+import { diffLocal, hasChanges, scanProject } from "../localFiles"
+import { CliError, c, info, success, progress, endProgress, flagBool, sha256, toKey, type Args } from "../util"
+
+/* `lecodes pull` — overwrite local files with the project's current remote state. Refuses to
+ * clobber uncommitted local edits unless --force. Given file/folder paths, pulls only those (a
+ * targeted "take the server's version of this file" for manual conflict resolution). */
+export const pull = async (args: Args) => {
+  const root = findProjectRoot(process.cwd())
+  const manifest = readManifest(root)
+  const config = loadConfig()
+  const apiUrl = requireApiUrl(config)
+  const token = requireToken(config)
+
+  // Targeted pull of specific paths — no dirty guard (the point is to merge into local edits) and
+  // baseHeadId is left as-is (you still owe a full pull/--force before a clean push).
+  if (args._.length > 0) {
+    const project = await getProject(apiUrl, token, manifest.uuid)
+    await pullPaths(root, manifest, project, args._.map(toKey), apiUrl, token)
+    return
+  }
+
+  if (!flagBool(args, "force") && hasChanges(diffLocal(manifest, scanProject(root, manifest)))) {
+    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)
+
+  // Remove tracked files that no longer exist remotely (untracked local files are left alone).
+  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 = join(root, ...path.replace(/^\//, "").split("/"))
+      if (existsSync(abs)) rmSync(abs)
+    }
+  }
+
+  const files = await materializeAssets(root, project, apiUrl, token, progress)
+  endProgress()
+  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)}.`)
+}
+
+const kindOf = (type: ProjectAsset["type"]): FileKind => (type === "file" ? "resource" : type as FileKind)
+
+/** Pull only the given paths (a file, or every file under a folder) from the server, in place. */
+const pullPaths = async (
+  root: string, manifest: ReturnType<typeof readManifest>, project: Project,
+  paths: string[], apiUrl: string, token: string,
+) => {
+  const pathById = buildPaths(project.assets)
+  const byPath = new Map<string, ProjectAsset>()
+  for (const asset of project.assets) byPath.set(pathById.get(asset.id)!, asset)
+
+  // Expand any folder argument to the files it contains.
+  const targets: ProjectAsset[] = []
+  for (const path of paths) {
+    const asset = byPath.get(path)
+    if (!asset) throw new CliError(`Not found on the server: ${path}`)
+    if (asset.type === "folder") {
+      const prefix = path + "/"
+      const under = project.assets.filter(a => a.type !== "folder" && pathById.get(a.id)!.startsWith(prefix))
+      if (under.length === 0) throw new CliError(`Folder is empty on the server: ${path}`)
+      targets.push(...under)
+    } else {
+      targets.push(asset)
+    }
+  }
+
+  const files = { ...manifest.files }
+  for (const asset of targets) {
+    const key = pathById.get(asset.id)!
+    const abs = join(root, ...key.replace(/^\//, "").split("/"))
+    mkdirSync(dirname(abs), { recursive: true })
+    let sha: string
+    if (asset.type === "file") {
+      if (!asset.file?.src) continue
+      const bytes = await downloadBlob(apiUrl, asset.file.src)
+      writeFileSync(abs, bytes)
+      sha = sha256(bytes)
+    } else {
+      const text = asset.text ?? ""
+      writeFileSync(abs, text)
+      sha = sha256(text)
+    }
+    files[key] = { id: asset.id, type: kindOf(asset.type), sha }
+    info(c.green(`  pulled  ${key}`))
+  }
+
+  writeManifest(root, { ...manifest, files })
+  success(`Pulled ${targets.length} file${targets.length === 1 ? "" : "s"} from the server.`)
+  info(c.dim("Local edits to other files are untouched. Run `lecodes diff` to review, then `lecodes push --force`."))
+}

package/src/commands/push.ts

@@ -0,0 +1,173 @@
+import { basename } from "node:path"
+import { readFileSync } from "node:fs"
+import { getCommits, getProject, publishProject, sync, uploadBlob, type Project, type SyncFileInput, type SyncFolderInput } from "../api"
+import { loadConfig, requireApiUrl, requireToken } from "../config"
+import { findProjectRoot, readManifest, writeManifest, type FileKind, type Manifest, type ManifestFile } from "../manifest"
+import { classifyKind, diffLocal, hasChanges, isTextKind, scanProject } from "../localFiles"
+import { computeServerDiff } from "../serverDiff"
+import { buildPaths } from "../project"
+import { CliError, c, confirm, flagBool, flagStr, info, log, prompt, success, warn, type Args } from "../util"
+
+/*
+ * `lecodes push -m "message"` — diff the working tree against the manifest, upload changed binaries,
+ * then POST /sync (atomic set-tree + one checkpoint). Identity is carried via assetId so renames /
+ * moves keep their history; unchanged binaries are referenced by id and never re-uploaded.
+ *
+ * With --publish the push also deploys the project (compile → live bundle) in the same /sync call,
+ * so the changes go live atomically. On a clean tree, --publish just deploys the current state.
+ *
+ * It also carries the design board's queued comment writes — replies and resolutions Claude or the
+ * developer wrote locally. They go AFTER the design, deliberately: a reply saying "fixed" that
+ * arrives before the fix is a lie the reviewer has no way to detect. That ordering is why nothing
+ * else in the toolchain sends a comment upward.
+ */
+export const push = async (args: Args) => {
+  const root = findProjectRoot(process.cwd())
+  const manifest = readManifest(root)
+  const config = loadConfig()
+  const apiUrl = requireApiUrl(config)
+  const token = requireToken(config)
+
+  const publish = flagBool(args, "publish")
+  const scan = scanProject(root, manifest)
+  const diff = diffLocal(manifest, scan)
+  if (!hasChanges(diff)) {
+    if (publish) {
+      await publishProject(apiUrl, token, manifest.uuid)
+      success("No file changes — published the current project state.")
+    } else {
+      info(c.dim("Working tree clean — nothing to push."))
+    }
+    // Still flush: a queued answer must not be stuck behind "no files changed", which is exactly the
+    // state you're in after resolving a comment about something you already pushed.
+    await flushComments(args)
+    return
+  }
+
+  const force = flagBool(args, "force")
+  // Concurrency guard: a push rewrites the server's WHOLE tree (set-tree), so anything that changed
+  // on the server since we cloned/pulled would be clobbered. Two kinds of drift to catch:
+  if (!force && manifest.baseHeadId !== null) {
+    const commits = await getCommits(apiUrl, token, manifest.uuid)
+    // (1) A new checkpoint was frozen on the server — that advances the head id.
+    if (commits.headId !== manifest.baseHeadId) {
+      throw new CliError("The project changed on the server since your last sync. Run `lecodes diff` to compare, `lecodes pull` to take the server's version, or `lecodes push --force` to overwrite.")
+    }
+    // (2) Uncommitted web-editor edits live in the head IN PLACE — same head id, just `dirty`. They
+    // still get rewritten by the set-tree push, so if the live head's file set has drifted from our
+    // manifest (e.g. a resource was added in the editor) a blind push would silently DELETE it. Bail.
+    if (commits.dirty) {
+      const drift = serverPathDrift(await getProject(apiUrl, token, manifest.uuid), manifest)
+      if (drift) {
+        throw new CliError(`The project has uncommitted changes in the web editor your checkout doesn't have (${drift}). Run \`lecodes pull\` to take them, or \`lecodes push --force\` to overwrite the server.`)
+      }
+    }
+  }
+
+  // With --force we may clobber server-side edits. Show exactly what changes on the server and
+  // confirm (interactive only; skip with --yes or when piped).
+  if (force) {
+    const project = await getProject(apiUrl, token, manifest.uuid)
+    const serverDiff = computeServerDiff(project, scan)
+    if (serverDiff.length) {
+      info(c.yellow(`--force will overwrite the server. ${serverDiff.length} file${serverDiff.length === 1 ? "" : "s"} change:`))
+      const label: Record<string, string> = { added: c.green("  create  "), removed: c.red("  delete  "), modified: c.yellow("  update  ") }
+      for (const e of serverDiff) log(label[e.status] + e.path + (e.binary ? c.dim(" (binary)") : ""))
+      if (process.stdin.isTTY && !flagBool(args, "y", "yes")) {
+        if (!(await confirm("Overwrite the server with your local copy?", false))) { info(c.dim("Aborted.")); return }
+      }
+    }
+  }
+
+  const message = (flagStr(args, "m", "message") ?? await prompt("Checkpoint message")) || "Update from lecodes CLI"
+
+  // The identity source for a path: the same path in the manifest, else its move origin.
+  const sourceFor = (path: string): ManifestFile | undefined =>
+    manifest.files[path] ?? (diff.moves.has(path) ? manifest.files[diff.moves.get(path)!] : undefined)
+
+  const files: SyncFileInput[] = []
+  let uploaded = 0
+  for (const file of scan.files) {
+    const source = sourceFor(file.path)
+    const kind: FileKind = source?.type ?? classifyKind(basename(file.path))
+    const entry: SyncFileInput = { path: file.path, type: kind }
+    if (source) entry.assetId = source.id
+
+    if (isTextKind(kind)) {
+      entry.text = readFileSync(file.absPath, "utf8")
+    } else if (!source || source.sha !== file.sha) {
+      // New or changed binary — upload it and reference the fresh blob.
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename(file.path), readFileSync(file.absPath))
+      entry.blobFileId = blob.id
+      uploaded++
+    }
+    // Else: unchanged binary — assetId alone tells the server to keep the existing blob.
+    files.push(entry)
+  }
+
+  const folders: SyncFolderInput[] = 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, publish })
+  if (!res.created) {
+    info(c.dim("Server reported no changes."))
+    if (publish) reportPublish(res)
+    return
+  }
+
+  // Rebuild the manifest from the authoritative server tree + local hashes.
+  const shaByPath = new Map(scan.files.map(f => [f.path, f.sha]))
+  const newFiles: Record<string, ManifestFile> = {}
+  for (const node of res.nodes) {
+    newFiles[node.path] = { id: node.id, type: node.type as FileKind, 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}`)
+  if (publish) reportPublish(res)
+  await flushComments(args)
+}
+
+/** Send the design board's queued comment writes, now that the design they describe is up. Silent
+ *  when there's no design folder, no queue, or no login — this is a rider on the push, not a step
+ *  the user asked for. */
+const flushComments = async (args: Args) => {
+  const { flushDesignComments } = await import("./design")
+  const result = await flushDesignComments(args)
+  if (!result) return
+  if (result.threads) {
+    success(`Sent ${result.sent} comment update${result.sent === 1 ? "" : "s"} across ${result.threads} thread${result.threads === 1 ? "" : "s"}.`)
+  }
+  for (const failure of result.failures) warn(`Comment not sent — ${failure} (still queued; the next push retries it).`)
+}
+
+/** How the server's current file set differs from what we last synced (the manifest), or null when
+ *  it matches. Catches files added/removed out-of-band (e.g. in the web editor) that a set-tree push
+ *  would otherwise clobber — see the concurrency guard above. Compares paths only (no false positives
+ *  for CLI-only flows, where the manifest is rebuilt from the server tree on every clone/pull/push). */
+const serverPathDrift = (project: Project, manifest: Manifest): string | null => {
+  const pathById = buildPaths(project.assets)
+  const serverPaths = new Set(project.assets.filter(a => a.type !== "folder").map(a => pathById.get(a.id)!))
+  const manifestPaths = new Set(Object.keys(manifest.files))
+  const added = [...serverPaths].filter(p => !manifestPaths.has(p))
+  const removed = [...manifestPaths].filter(p => !serverPaths.has(p))
+  const describe = (label: string, paths: string[]) =>
+    `${paths.length} ${label} on the server: ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}`
+  const parts = [
+    added.length ? describe("added", added) : "",
+    removed.length ? describe("removed", removed) : "",
+  ].filter(Boolean)
+  return parts.length ? parts.join("; ") : null
+}
+
+/** Report the outcome of a --publish deploy bundled with the push (best-effort on the server). */
+const reportPublish = (res: { published?: boolean, publishError?: string }) => {
+  if (res.published) success("Published — the project is now live.")
+  else warn(`Push landed, but publish failed: ${res.publishError ?? "unknown error"}`)
+}