lecodes-cli 0.20.2 → 2.0.0

package/src/commands/push.ts

@@ -1,12 +1,12 @@
-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"
+import { basename } from "node:path"
+import { CliError, bool, c, confirm, defineCommand, info, log, prompt, str, success, warn } from "../cli"
+import { getCommits, getProject, publishProject, sync, uploadBlob, type Project, type SyncFileInput, type SyncFolderInput } from "../platform/api"
+import { computeServerDiff } from "../platform/serverDiff"
+import { classifyKind, diffLocal, hasChanges, isTextKind, scanProject } from "../project/localFiles"
+import { writeManifest, type FileKind, type Manifest, type ManifestFile } from "../project/manifest"
+import { buildPaths } from "../project/materialize"
+import { linkedProject } from "./shared"
 
 /*
  * `lecodes push -m "message"` — diff the working tree against the manifest, upload changed binaries,
@@ -21,33 +21,42 @@ import { CliError, c, confirm, flagBool, flagStr, info, log, prompt, success, wa
  * 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")
+
+export const pushFlags = {
+  message: str("checkpoint message (asked for when omitted)", { alias: "m", value: "<text>" }),
+  publish: bool("also deploy the project live (compile) with the push"),
+  force: bool("push even if the server moved on (shows + confirms which server files get overwritten)"),
+  yes: bool("skip the --force overwrite confirmation", { alias: "y" }),
+}
+
+export type PushOptions = { message?: string, publish?: boolean, force?: boolean, yes?: boolean }
+
+export default defineCommand({
+  name: "push",
+  summary: "Push local changes as one new checkpoint",
+  flags: pushFlags,
+  examples: ['lecodes push -m "Tweak the menu"', "lecodes push --publish"],
+  run: ({ flags }) => runPush(flags),
+})
+
+/** The push itself — `lecodes link --push` runs it too. */
+export const runPush = async (opts: PushOptions): Promise<void> => {
+  const { root, manifest, apiUrl, token } = linkedProject()
+  const publish = !!opts.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."))
-    }
+    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)
+    await flushComments()
     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) {
+  if (!opts.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) {
@@ -58,28 +67,24 @@ export const push = async (args: Args) => {
     // 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.`)
-      }
+      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) {
+  if (opts.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 }
-      }
+      if (process.stdin.isTTY && !opts.yes && !(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"
+  const message = (opts.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 =>
@@ -92,10 +97,8 @@ export const push = async (args: Args) => {
     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) {
+    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
@@ -104,7 +107,6 @@ export const push = async (args: Args) => {
     // 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"}.`))
@@ -118,9 +120,7 @@ export const push = async (args: Args) => {
   // 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) ?? "" }
-  }
+  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 = [
@@ -131,19 +131,17 @@ export const push = async (args: Args) => {
   ].filter(Boolean).join(", ")
   success(`Pushed checkpoint${res.seq ? ` #${res.seq}` : ""}${counts ? ` (${counts})` : ""}: ${message}`)
   if (publish) reportPublish(res)
-  await flushComments(args)
+  await flushComments()
 }
 
 /** 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 flushComments = async (): Promise<void> => {
   const { flushDesignComments } = await import("./design")
-  const result = await flushDesignComments(args)
+  const result = await flushDesignComments()
   if (!result) return
-  if (result.threads) {
-    success(`Sent ${result.sent} comment update${result.sent === 1 ? "" : "s"} across ${result.threads} thread${result.threads === 1 ? "" : "s"}.`)
-  }
+  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).`)
 }
 
@@ -157,17 +155,13 @@ const serverPathDrift = (project: Project, manifest: Manifest): string | null =>
   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)
+  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 }) => {
+const reportPublish = (res: { published?: boolean, publishError?: string }): void => {
   if (res.published) success("Published — the project is now live.")
   else warn(`Push landed, but publish failed: ${res.publishError ?? "unknown error"}`)
 }