lecodes-cli 0.20.1 → 1.0.0

package/src/commands/scene.ts

@@ -1,15 +1,15 @@
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs"
-import { basename, dirname, join, resolve } from "node:path"
-import { findProjectRoot, readManifest, type Manifest } from "../manifest"
+import { basename, dirname, join, relative, resolve } from "node:path"
+import { CliError, bool, c, defineCommand, log, note, num, warnErr } from "../cli"
 import { compileSceneEditor } from "../compile/sceneCompile"
 import { localShaderArtifact } from "../compile/shaders"
-import { openBrowser } from "../browserAuth"
-import { CliError, c, flagBool, flagStr, log, note, warnErr, type Args } from "../util"
-import { loadPeer } from "../peerInstall"
+import { loadPeer } from "../hosts/peerInstall"
+import { openBrowser } from "../platform/browserAuth"
+import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
 
 /*
- * `lecodes scene [path]` — the 3D scene editor (lecodes-tools/packages/lecodes-3d-editor) hosted on a local project,
- * exactly the way `lecodes design` hosts the design board. Starts scene-editor's node:http server,
+ * `lecodes scene [path]` — the 3D scene editor (lecodes-tools/packages/lecodes-3d-editor) hosted on a
+ * local project, the way `lecodes design` hosts the design board. Starts the editor's node:http server,
  * injects the CLI's compile closure (chisel + the vendored SDK + a vendored harness), and opens the
  * browser. `.scene.ts` files are edited visually (tree + inspector) and written back to disk;
  * external (IDE) edits hot-reload over SSE.
@@ -25,6 +25,9 @@ type SceneContext = {
   /** Null in standalone mode: the scene lives outside any cloned lecodes project. */
   manifest: Manifest | null
   name: string
+  /** The `.scene.ts` the positional arg named, as a project path ("./src/map.scene.ts") — the
+   *  editor opens on it (`?scene=`) instead of the project's first scene file. */
+  scene: string | null
 }
 
 /** The nearest ancestor (inclusive) holding an `app.json` — a local project's root — or null. */
@@ -42,14 +45,10 @@ const findAppRoot = (start: string): string | null => {
  *  app.json, else the directory itself. `lecodes thumbs` resolves its root this way — its
  *  positional args are targets, not the root, so it can't go through getContext. */
 export const projectRootOf = (dir: string): string => {
-  try {
-    return findProjectRoot(dir)
-  } catch {
-    return findAppRoot(dir) ?? dir
-  }
+  try { return findProjectRoot(dir) } catch { return findAppRoot(dir) ?? dir }
 }
 
-const getContext = (args: Args): SceneContext => {
+const getContext = (pathArg: string | undefined): SceneContext => {
   let root: string
   let manifest: Manifest | null
   try {
@@ -62,7 +61,6 @@ const getContext = (args: Args): SceneContext => {
     // `app.json`; only without one does a scene path fall back to its containing dir.
     root = process.cwd()
     manifest = null
-    const pathArg = args._[0]
     if (pathArg) {
       const abs = resolve(process.cwd(), pathArg)
       if (existsSync(abs) && statSync(abs).isDirectory()) root = abs
@@ -72,23 +70,25 @@ const getContext = (args: Args): SceneContext => {
       root = findAppRoot(root) ?? root
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename(root) }
+  // a `.scene.ts` arg (either mode) picks the file the editor opens on
+  let scene: string | null = null
+  if (pathArg?.endsWith(".scene.ts")) {
+    const abs = resolve(process.cwd(), pathArg)
+    const rel = relative(root, abs).replace(/\\/g, "/")
+    if (existsSync(abs) && !rel.startsWith("..")) scene = "./" + rel
+  }
+  return { root, manifest, name: manifest?.name ?? basename(root), scene }
 }
 
 /** Register the scene server as a project-scoped MCP server so Claude Code auto-discovers its
- *  scene_state / check_scene tools. Merges into an existing .mcp.json (never clobbers a broken one).
- *  Ported from `lecodes design init`'s writer; keyed "lecodes-scene". */
-const writeMcpConfig = (root: string, port: number) => {
+ *  scene_state / check_scene tools. Merges into an existing .mcp.json (never clobbers a broken one). */
+const writeMcpConfig = (root: string, port: number): void => {
   const path = join(root, ".mcp.json")
   const entry = { type: "http", url: `http://localhost:${port}/mcp` }
   let config: { mcpServers?: Record<string, unknown> } = {}
   if (existsSync(path)) {
-    try {
-      config = JSON.parse(readFileSync(path, "utf8"))
-    } catch {
-      warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.")
-      return
-    }
+    try { config = JSON.parse(readFileSync(path, "utf8")) }
+    catch { warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand."); return }
   }
   config.mcpServers ??= {}
   const existing = config.mcpServers["lecodes-scene"] as { url?: string } | undefined
@@ -98,7 +98,7 @@ const writeMcpConfig = (root: string, port: number) => {
   note(`${existing ? "updated" : "created"}   .mcp.json (lecodes-scene MCP → ${entry.url})`)
 }
 
-/** Recursively find the first-level count of `.scene.ts` files under root (skip node_modules/dotdirs). */
+/** How many `.scene.ts` files sit under root (node_modules / dot-dirs skipped). */
 const countScenes = (dir: string): number => {
   let n = 0
   for (const name of readdirSync(dir)) {
@@ -110,35 +110,38 @@ const countScenes = (dir: string): number => {
   return n
 }
 
-export const scene = async (args: Args) => {
-  const ctx = getContext(args)
-
-  const sceneServer = await loadPeer<typeof import("lecodes-3d-editor/server")>("lecodes-3d-editor", "server", { for: "lecodes scene" })
+export default defineCommand({
+  name: "scene",
+  summary: "The scene editor: edit a .scene.ts visually (tree, inspector, gizmo)",
+  usage: "[path]",
+  description: "Needs the optional lecodes-3d-editor package (installed on first use). Works inside a cloned project or standalone in any folder; `path` is a folder or a .scene.ts to host. Registers an MCP server in .mcp.json so Claude Code can call scene_state / check_scene.",
+  flags: {
+    port: num("editor-server port", { default: DEFAULT_PORT }),
+    "no-open": bool("don't open the browser"),
+    "no-mcp": bool("don't register the MCP server in .mcp.json"),
+  },
+  examples: ["lecodes scene", "lecodes scene src/forest.scene.ts --no-open"],
+  run: async ({ args, flags }) => {
+    const ctx = getContext(args[0])
+    const sceneServer = await loadPeer<typeof import("lecodes-3d-editor/server")>("lecodes-3d-editor", "server", { for: "lecodes scene" })
+    if (countScenes(ctx.root) === 0) warnErr(`No .scene.ts file under ${ctx.root} yet — add one and the editor will pick it up.`)
 
-  const port = Number(flagStr(args, "port")) || DEFAULT_PORT
+    const server = await sceneServer.startSceneServer({
+      root: ctx.root,
+      port: flags.port,
+      log: note,
+      compile: (scenePath: string) => compileSceneEditor({ root: ctx.root, manifest: ctx.manifest, name: ctx.name, scenePath }),
+      // live material patches load a shader's compiled artifact (matc'd for the Rendered mode,
+      // the lite JSON otherwise) from the local shader cache
+      shaderArtifact: (shaderText, platform) => localShaderArtifact(ctx.root, shaderText, platform),
+    })
+    if (!flags["no-mcp"]) writeMcpConfig(ctx.root, flags.port)
 
-  if (countScenes(ctx.root) === 0) {
-    warnErr(`No .scene.ts file under ${ctx.root} yet — add one and the editor will pick it up.`)
-  }
-
-  const server = await sceneServer.startSceneServer({
-    root: ctx.root,
-    port,
-    log: note,
-    compile: (scenePath: string) => compileSceneEditor({
-      root: ctx.root, manifest: ctx.manifest, name: ctx.name, scenePath,
-    }),
-    // live material patches load a shader's compiled artifact (matc'd for the Rendered mode,
-    // the lite JSON otherwise) from the local shader cache
-    shaderArtifact: (shaderText, platform) => localShaderArtifact(ctx.root, shaderText, platform),
-  })
-
-  // Let Claude Code reach the running server over MCP (scene_state / check_scene), unless opted out.
-  if (!flagBool(args, "no-mcp")) writeMcpConfig(ctx.root, port)
-
-  log(`${c.bold("LeCodes Scene Editor")} — ${ctx.name}`)
-  log(`Editor:   ${c.bold(server.url)}`)
-  log(`MCP:      ${c.bold(server.url + "/mcp")}`)
-  log(`Watching: ${ctx.root}  (scenes hot-reload on save; Ctrl+C to stop)`)
-  if (!flagBool(args, "no-open")) openBrowser(server.url)
-}
+    log(`${c.bold("LeCodes Scene Editor")} — ${ctx.name}`)
+    const editorUrl = ctx.scene ? `${server.url}/?scene=${encodeURIComponent(ctx.scene.replace(/^\.\//, ""))}` : server.url
+    log(`Editor:   ${c.bold(editorUrl)}`)
+    log(`MCP:      ${c.bold(server.url + "/mcp")}`)
+    log(`Watching: ${ctx.root}  (scenes hot-reload on save; Ctrl+C to stop)`)
+    if (!flags["no-open"]) openBrowser(editorUrl)
+  },
+})

package/src/commands/{shaders.ts → shaders/index.ts}

@@ -1,15 +1,15 @@
 import { readFileSync } from "node:fs"
 import { relative } from "node:path"
-import { findProjectRoot, readManifest, type Manifest } from "../manifest"
-import { collectLocalEntries } from "../compile/collectLocal"
+import { collectLocalEntries } from "../../compile/collectLocal"
 import {
   allShaderPlatforms, applyLocalShaders, matcIdentity, shaderCompiledPlatforms, shaderIsCompiled,
   shadersCacheDir,
-} from "../compile/shaders"
-import { fetchMatcManifest, installedMatcVersions, resolveMatcExe, resolveMatcExeCached, updateMatc } from "../matcTool"
-import { semverNewer } from "../releases"
-import { CliError, c, flagStr, log, note, warnErr, type Args } from "../util"
-import { engineMaterialNames, writeNewShader } from "./shadersNew"
+} from "../../compile/shaders"
+import { fetchMatcManifest, installedMatcVersions, resolveMatcExe, resolveMatcExeCached, updateMatc } from "../../hosts/matcTool"
+import { semverNewer } from "../../hosts/releases"
+import { CliError, UsageError, bool, c, defineCommand, log, note, str, warnErr } from "../../cli"
+import { localProject } from "../shared"
+import { engineMaterialNames, writeNewShader } from "./new"
 import { parseShaderSchema, type AnyShaderPlatform } from "lecodes-sdk/compile"
 
 /*
@@ -21,7 +21,7 @@ import { parseShaderSchema, type AnyShaderPlatform } from "lecodes-sdk/compile"
  *   update      download the newest published matc (run after an engine upgrade)
  *   new <name>  a fresh .mat + its .material.ts asset in the current dir (--dir elsewhere): the
  *               starter template, or `--ref lit|unlit|particles|…` = a copy of that engine source
- *               to start from (shadersNew.ts); --force overwrites
+ *               to start from (new.ts); --force overwrites
  * matc (Filament's material compiler) caches in ~/.lecodes/matc/; LECODES_MATC overrides it.
  *
  * A shader compiles to one artifact per target: `opengl` + `metal` (mobile profile, Android/Apple),
@@ -34,20 +34,12 @@ import { parseShaderSchema, type AnyShaderPlatform } from "lecodes-sdk/compile"
 
 /** The project's shader entries from the working tree (works with or without a server manifest). */
 const collectShaders = () => {
-  let root: string
-  let manifest: Manifest | null
-  try {
-    root = findProjectRoot(process.cwd())
-    manifest = readManifest(root)
-  } catch {
-    root = process.cwd()
-    manifest = null
-  }
+  const { root, manifest } = localProject()
   const { entries } = collectLocalEntries(root, manifest, "", { localShaders: true })
   return { root, entries, shaders: entries.filter((e) => e.type === "shader" && e.absPath) }
 }
 
-const status = async () => {
+const status = async (): Promise<void> => {
   const { root, shaders } = collectShaders()
 
   const installed = installedMatcVersions()
@@ -104,8 +96,7 @@ const status = async () => {
 
 /** Parse `--platform a,b` into a validated target list. A typo must fail loudly: silently compiling
  *  nothing would look like success and leave the cache short of what the caller asked for. */
-const parsePlatforms = (args: Args): AnyShaderPlatform[] | undefined => {
-  const raw = flagStr(args, "platform", "platforms")
+const parsePlatforms = (raw: string | undefined): AnyShaderPlatform[] | undefined => {
   if (raw === undefined) return undefined
   const known = allShaderPlatforms()
   const asked = raw.split(",").map((p) => p.trim()).filter(Boolean)
@@ -119,11 +110,10 @@ const parsePlatforms = (args: Args): AnyShaderPlatform[] | undefined => {
 
 /** Compile every project shader into the local cache — what `lecodes dev` does lazily, run
  *  explicitly (e.g. to pre-warm before going offline, or to see all compile errors at once).
- *  `--platform` narrows the targets; compiling is incremental per artifact, so a narrow run now and
- *  a full one later add up rather than redoing each other's work. */
-const compile = async (args: Args) => {
-  const platforms = parsePlatforms(args)
-  const { root, entries, shaders } = collectShaders()
+ *  `platforms` narrows the targets; compiling is incremental per artifact, so a narrow run now and
+ *  a full one later add up rather than redoing each other's work. `lecodes update` runs it too. */
+export const compileShaders = async (platforms?: AnyShaderPlatform[]): Promise<void> => {
+  const { root, shaders } = collectShaders()
   if (shaders.length === 0) {
     note("No .mat shaders in this project.")
     return
@@ -153,21 +143,50 @@ const compile = async (args: Args) => {
   note(`${shaders.length} shader${shaders.length === 1 ? "" : "s"} compiled${scope} → ${shadersCacheDir(root)}`)
 }
 
-const newShader = (args: Args) => {
-  const name = args._[1]
-  if (!name) throw new CliError(`lecodes shaders new <name> [--ref ${engineMaterialNames().join("|") || "lit"}] [--dir <folder>] [--force]`)
-  const res = writeNewShader({ name, ref: flagStr(args, "ref"), dir: flagStr(args, "dir"), force: args.flags.force === true })
-  const rel = (p: string) => relative(process.cwd(), p)
-  log(`${rel(res.mat)}  ${c.dim(res.ref ? `(from the engine's ${res.ref}.mat)` : "(the starter template)")}`)
-  log(`${rel(res.asset)}  ${c.dim("(defineMaterial asset — a scene takes it as `material:`)")}`)
-  note(`next: edit it, then \`lecodes shaders compile\` (or just \`lecodes dev\`); in code: Material.load(asset('./${name.replace(/\.mat$/, "")}.mat'))`)
-}
+const compile = defineCommand({
+  name: "compile",
+  summary: "Compile every shader into .lecodes/shaders (the pass `lecodes dev` runs on the fly)",
+  description: "Downloads matc on first use (~/.lecodes/matc). Every target is compiled by default (opengl, metal, desktop, desktop-vulkan, webgl-lite) because one bundle serves every host; --platform narrows it when you know the target. Incremental per artifact.",
+  flags: {
+    platform: str("only these targets, comma-separated (opengl, metal, desktop, desktop-vulkan, webgl-lite)", { value: "<a,b>" }),
+  },
+  examples: ["lecodes shaders compile", "lecodes shaders compile --platform desktop"],
+  run: ({ flags }) => compileShaders(parsePlatforms(flags.platform)),
+})
 
-export const shaders = async (args: Args) => {
-  const sub = args._[0]
-  if (sub === undefined) return status()
-  if (sub === "compile") return compile(args)
-  if (sub === "update") return updateMatc()
-  if (sub === "new") return newShader(args)
-  throw new CliError(`Unknown subcommand "shaders ${sub}". Use \`lecodes shaders\` (status), \`lecodes shaders compile [--platform a,b]\`, \`lecodes shaders new <name> [--ref lit]\` or \`lecodes shaders update\`.`)
-}
+const update = defineCommand({
+  name: "update",
+  summary: "Download the newest published matc (run after an engine upgrade)",
+  run: () => updateMatc(),
+})
+
+const newShader = defineCommand({
+  name: "new",
+  summary: "Write a fresh .mat + .material.ts: the starter, or a copy of an engine material",
+  usage: "<name>",
+  description: "The starter is an unlit material with an annotated parameter of each kind. `--ref lit|unlit|particles|…` copies the engine's own source instead, renamed after the file — the way to get vertex colours, an emissive term or a second map onto an otherwise standard material without touching the engine. A <name>.material.ts asset (defineMaterial with the declared parameters) goes next to it.",
+  flags: {
+    ref: str("start from the engine's material of that name (lit, unlit, particles, …)", { value: "<name>" }),
+    dir: str("write into this folder instead of the current dir", { value: "<folder>" }),
+    force: bool("overwrite existing files"),
+  },
+  examples: ["lecodes shaders new hologram", "lecodes shaders new rim-light --ref lit --dir assets/shaders"],
+  run: ({ args, flags }) => {
+    const name = args[0]
+    if (!name) throw new UsageError(`Which shader? lecodes shaders new <name> [--ref ${engineMaterialNames().join("|") || "lit"}] [--dir <folder>] [--force]`)
+    const res = writeNewShader({ name, ref: flags.ref, dir: flags.dir, force: flags.force })
+    const rel = (p: string) => relative(process.cwd(), p)
+    log(`${rel(res.mat)}  ${c.dim(res.ref ? `(from the engine's ${res.ref}.mat)` : "(the starter template)")}`)
+    log(`${rel(res.asset)}  ${c.dim("(defineMaterial asset — a scene takes it as `material:`)")}`)
+    note(`next: edit it, then \`lecodes shaders compile\` (or just \`lecodes dev\`); in code: Material.load(asset('./${name.replace(/\.mat$/, "")}.mat'))`)
+  },
+})
+
+export default defineCommand({
+  name: "shaders",
+  summary: "The project's custom shaders (.mat): list, compile, update matc, new",
+  description: "Bare `lecodes shaders` lists the project's shaders with their compile state and the matc status. matc (Filament's material compiler) caches in ~/.lecodes/matc; LECODES_MATC points at a local build.",
+  commands: [compile, update, newShader],
+  examples: ["lecodes shaders", "lecodes shaders compile", "lecodes shaders new hologram --ref lit"],
+  run: () => status(),
+})

package/src/commands/{shadersNew.ts → shaders/new.ts}

@@ -12,8 +12,8 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
 import { basename, join, relative, resolve } from "node:path"
 import { parseShaderSchema } from "lecodes-sdk/compile"
-import { distRoot } from "../distRoot"
-import { CliError } from "../util"
+import { distRoot } from "../../hosts/distRoot"
+import { CliError } from "../../cli"
 
 /** where the engine's .mat sources are, or null when this CLI carries none */
 export const engineMaterialsDir = (): string | null => {

package/src/commands/shared.ts

@@ -0,0 +1,79 @@
+import { basename } from "node:path"
+import { bool, str, type FlagValues } from "../cli"
+import { loadConfig, requireApiUrl, requireToken } from "../platform/config"
+import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
+
+/*
+ * What several commands share: the flag groups (spread into a command's `flags:`) and the
+ * "where am I / who am I" lookups every platform command starts with.
+ */
+
+// ---- flag groups -----------------------------------------------------------------------------
+
+/** How the project is compiled — `compile`, `dev`, `render`, `test`, `desktop run`, `app sync` … */
+export const bundleFlags = {
+  entry: str("compile from this entry instead of the detected one", { value: "<path>" }),
+  "public-url": str("resolve assets from this URL prefix (default: the API origin / the working tree)", { value: "<url>" }),
+  "remote-assets": bool("desktop hosts: load asset() resources from the server instead of the working tree"),
+  "no-header": bool("omit the metadata header"),
+  "no-minify": bool("keep the bundle readable (no compress / mangle)"),
+  "no-sourcemap": bool("don't generate / inline the source map"),
+}
+
+/** `-o` for commands whose result is a file. */
+export const outFlag = { out: str("write to this file instead of stdout", { alias: "o", value: "<file>" }) }
+
+/** The compiler's view of the bundle flags (see compile.ts `buildBundle`). */
+export type BundleOptions = {
+  entry?: string
+  publicUrl?: string
+  remoteAssets?: boolean
+  header?: boolean
+  minify?: boolean
+  sourcemap?: boolean
+}
+
+export const bundleOptions = (flags: FlagValues<typeof bundleFlags>): BundleOptions => ({
+  entry: flags.entry,
+  publicUrl: flags["public-url"],
+  remoteAssets: flags["remote-assets"],
+  header: !flags["no-header"],
+  // Both default on; `false` only when the flag is present, so the SDK's own defaults stand.
+  minify: flags["no-minify"] ? false : undefined,
+  sourcemap: flags["no-sourcemap"] ? false : undefined,
+})
+
+// ---- where / who -----------------------------------------------------------------------------
+
+export type Session = { apiUrl: string, token: string }
+
+/** The logged-in session (api origin + token) or a "run `lecodes login`" error. */
+export const session = (): Session => {
+  const config = loadConfig()
+  return { apiUrl: requireApiUrl(config), token: requireToken(config) }
+}
+
+export type LinkedProject = Session & { root: string, manifest: Manifest }
+
+/** A server-backed checkout: the project root (found upward from the cwd), its manifest and the session. */
+export const linkedProject = (): LinkedProject => {
+  const root = findProjectRoot(process.cwd())
+  return { root, manifest: readManifest(root), ...session() }
+}
+
+export type LocalProject = { root: string, manifest: Manifest | null, name: string }
+
+/** Any project: a linked checkout, else the current folder standing alone (no login needed). */
+export const localProject = (): LocalProject => {
+  try {
+    const root = findProjectRoot(process.cwd())
+    const manifest = readManifest(root)
+    return { root, manifest, name: manifest.name }
+  } catch {
+    const root = process.cwd()
+    return { root, manifest: null, name: basename(root) }
+  }
+}
+
+/** A folder name for a project: lower-case, dashes, never empty. */
+export const slugOf = (name: string): string => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project"

package/src/commands/status.ts

@@ -1,29 +1,25 @@
-import { findProjectRoot, readManifest } from "../manifest"
-import { diffLocal, hasChanges, scanProject } from "../localFiles"
-import { c, info, log, type Args } from "../util"
+import { c, defineCommand, info, log } from "../cli"
+import { diffLocal, hasChanges, scanProject } from "../project/localFiles"
+import { linkedProject } from "./shared"
 
-/* `lecodes status` — show local changes vs the last clone/pull/push. */
-export const status = async (_args: Args) => {
-  const root = findProjectRoot(process.cwd())
-  const manifest = readManifest(root)
-  const scan = scanProject(root, manifest)
-  const diff = diffLocal(manifest, scan)
+/* `lecodes status` — local changes vs the last clone / pull / push. */
+export default defineCommand({
+  name: "status",
+  summary: "Show local changes vs the last sync",
+  run: () => {
+    const { root, manifest } = linkedProject()
+    const scan = scanProject(root, manifest)
+    const diff = diffLocal(manifest, scan)
 
-  info(`Project ${c.bold(manifest.name)} (${manifest.uuid})`)
-  const ignoredNote = scan.ignored.length ? c.dim(` (${scan.ignored.length} ignored)`) : ""
-  if (!hasChanges(diff)) {
-    info(c.dim("Working tree clean — nothing to push.") + ignoredNote)
-    return
-  }
+    info(`Project ${c.bold(manifest.name)} (${manifest.uuid})`)
+    const ignoredNote = scan.ignored.length ? c.dim(` (${scan.ignored.length} ignored)`) : ""
+    if (!hasChanges(diff)) { info(c.dim("Working tree clean — nothing to push.") + ignoredNote); 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}`))
-  }
-  if (scan.ignored.length) info(c.dim(`  ${scan.ignored.length} ignored (.lecodesignore)`))
-}
+    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}`))
+    if (scan.ignored.length) info(c.dim(`  ${scan.ignored.length} ignored (.lecodesignore)`))
+  },
+})