lecodes-cli 0.19.0 → 0.20.0

package/src/ignore.ts

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+/*
+ * `.lecodesignore` support — keeps scratch files (temp probes, render screenshots, logs) out of
+ * `status` / `push` so they never land in a checkpoint. Syntax is a practical subset of .gitignore:
+ *   - blank lines and `# comments` are skipped
+ *   - `!pattern` re-includes something a previous pattern ignored
+ *   - a trailing `/` matches directories only
+ *   - a leading `/` (or any embedded `/`) anchors the pattern to the project root
+ *   - `*` matches within a path segment, `**` across segments, `?` a single char
+ *   - a slash-free pattern (e.g. `_*`, `*.png`) matches a basename at any depth
+ *
+ * IMPORTANT: ignores apply to UNTRACKED files only. A file already in the project (recorded in the
+ * manifest) is always tracked, even if it matches a pattern — so ignoring `*.png` can never make an
+ * existing image asset silently disappear from the project. Pruning happens in `scanLocal`.
+ */
+
+export type IgnoreMatcher = (key: string, isDir: boolean) => boolean
+
+type Rule = { re: RegExp, negate: boolean, dirOnly: boolean }
+
+// Always applied, even with no .lecodesignore — only patterns that are never real project assets, so
+// they're safe as invisible defaults. Everything asset-shaped (*.png, *.json, …) is opt-in via the
+// file written at clone time (see DEFAULT_IGNORE_FILE). `.artifacts/` is `lecodes test`'s
+// failure-frame dump dir (tests/.artifacts/) — regenerated scratch, never a project asset.
+// `dist/` is `lecodes app build desktop`'s default output (<root>/dist/<slug>, appDesktop.ts) —
+// same class, but it must be ignored for a second, load-bearing reason: that folder holds a COPY of
+// the host's runtime assets (lit.filamat, uberarchive.bin, …). Collected as project assets they get
+// staged next to the bundle, and onFetchLocal searches the bundle's dir BEFORE the host's assets dir
+// (main.cpp) — so the copy shadows the host's own. Harmless while every host was OpenGL and the
+// bytes matched; fatal once a build output can come from the Vulkan host, where the shadowing
+// lit.filamat is SPIR-V and Filament aborts with "not built for any of the OpenGL backend's
+// supported shader languages".
+// `.env` / `.env.*`: the project's LECODES_* config (projectEnv.ts) — it holds tokens and keystore
+// passwords, so it never leaves the machine whatever .lecodesignore says.
+const BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*"]
+
+/** Template `.lecodesignore` written on clone — the explicit, editable "what we don't push" list. */
+export const DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
+# Only untracked files are affected — assets already in the project stay tracked
+# even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
+# always apply.
+
+# Render / preview outputs (the default \`lecodes render --png\` target)
+screenshot.png
+shots/
+
+# Design-board comments live on the platform; design/comments/ is the local mirror of the
+# open ones (\`lecodes design comments pull\`) — read by Claude, but pushing it back as
+# project files would only duplicate the database.
+design/comments/
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
+
+# Local notes & dumps (uncomment to ignore)
+# *.json
+# notes.md
+`
+
+/** Translate a glob (one path segment's worth of `*`/`?`/`**`) into a regex fragment. */
+const translate = (glob: string): string => {
+  let re = ""
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i]
+    if (ch === "*") {
+      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++ } // `**/` spans dirs
+      else re += "[^/]*"
+    } else if (ch === "?") re += "[^/]"
+    else if (ch === "/") re += "/"
+    else if ("\\^$.|+()[]{}".includes(ch)) re += "\\" + ch
+    else re += ch
+  }
+  return re
+}
+
+const compile = (raw: string): Rule | null => {
+  let p = raw.trim()
+  if (!p || p.startsWith("#")) return null
+  let negate = false
+  if (p.startsWith("!")) { negate = true; p = p.slice(1) }
+  let dirOnly = false
+  if (p.endsWith("/")) { dirOnly = true; p = p.slice(0, -1) }
+  const anchored = p.startsWith("/") || p.includes("/")
+  if (p.startsWith("/")) p = p.slice(1)
+  if (!p) return null
+  const body = translate(p)
+  // `(/.*)?$` lets a directory pattern also match files nested under it, matching gitignore behavior
+  // even without relying on directory pruning.
+  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$")
+  return { re, negate, dirOnly }
+}
+
+const buildMatcher = (rules: Rule[]): IgnoreMatcher => (key, isDir) => {
+  let ignored = false
+  for (const r of rules) {
+    if (r.dirOnly && !isDir) continue // a `foo/` rule only matches dirs directly (files via prune)
+    if (r.re.test(key)) ignored = !r.negate
+  }
+  return ignored
+}
+
+/** Compile a standalone glob list (same syntax as .lecodesignore lines, including `!` re-includes)
+ *  into a file-path matcher — used for app.json's `resources.remote` patterns. */
+export const buildGlobMatcher = (patterns: string[]): ((path: string) => boolean) => {
+  // Matching is over FILE paths — normalize `videos/` (dir-only, would match nothing here) to
+  // `videos`, whose `(/.*)?$` tail matches everything under the directory.
+  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r): r is Rule => r !== null)
+  const match = buildMatcher(rules)
+  // Anchored rules compile to `^/…` — they expect the canonical leading-slash key form.
+  return (path) => match(path.startsWith("/") ? path : "/" + path, false)
+}
+
+/** Read `<root>/.lecodesignore` (if any) and combine with the built-in defaults into a matcher. */
+export const loadIgnore = (root: string): IgnoreMatcher => {
+  const lines = [...BUILTIN_PATTERNS]
+  const file = join(root, ".lecodesignore")
+  if (existsSync(file)) {
+    try { lines.push(...readFileSync(file, "utf8").split(/\r?\n/)) } catch { /* unreadable → defaults only */ }
+  }
+  const rules = lines.map(compile).filter((r): r is Rule => r !== null)
+  return buildMatcher(rules)
+}
+
+/** Write the template `.lecodesignore` if the project doesn't have one yet (used on clone). */
+export const writeDefaultIgnore = (root: string) => {
+  const file = join(root, ".lecodesignore")
+  if (!existsSync(file)) writeFileSync(file, DEFAULT_IGNORE_FILE)
+}
+
+/* `.gitignore` for the project's OWN git repo. `.lecodes/` is per-checkout state — regenerable IDE
+ * types (`lecodes update`) + `manifest.json`, this machine's push cursor (baseHeadId + per-file shas).
+ * Committing it makes collaborators fight over the cursor and ship stale types, so every scaffold
+ * path (init / clone / link) makes sure it's ignored. Render outputs mirror DEFAULT_IGNORE_FILE. */
+export const DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
+# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
+.lecodes/
+
+# Render / preview outputs and test failure frames
+screenshot.png
+shots/
+tests/.artifacts/
+tests/.shots/
+
+node_modules/
+
+dist/
+`
+
+/** Create `.gitignore` if missing; if it exists but doesn't ignore `.lecodes/`, append that rule.
+ * Returns what happened so callers can log it ("created" | "updated" | null). */
+export const ensureGitignore = (root: string): "created" | "updated" | null => {
+  const file = join(root, ".gitignore")
+  if (!existsSync(file)) { writeFileSync(file, DEFAULT_GITIGNORE); return "created" }
+  const text = readFileSync(file, "utf8")
+  const covered = text.split(/\r?\n/).some(l => /^\/?\.lecodes\/?\s*$/.test(l.trim()))
+  if (covered) return null
+  const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n"
+  writeFileSync(file, `${text}${sep}\n# LeCodes per-checkout state (generated types + sync cursor) — not source\n.lecodes/\n`)
+  return "updated"
+}