@arcote.tech/arc-cli 0.5.6 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",
@@ -12,12 +12,12 @@
     "build": "bun build --target=bun ./src/index.ts --outdir=dist --external @arcote.tech/arc --external @arcote.tech/arc-ds --external @arcote.tech/arc-react --external @arcote.tech/platform && chmod +x dist/index.js"
   },
   "dependencies": {
-    "@arcote.tech/arc": "^0.5.6",
-    "@arcote.tech/arc-ds": "^0.5.6",
-    "@arcote.tech/arc-react": "^0.5.6",
-    "@arcote.tech/arc-host": "^0.5.6",
-    "@arcote.tech/arc-adapter-db-sqlite": "^0.5.6",
-    "@arcote.tech/platform": "^0.5.6",
+    "@arcote.tech/arc": "^0.5.8",
+    "@arcote.tech/arc-ds": "^0.5.8",
+    "@arcote.tech/arc-react": "^0.5.8",
+    "@arcote.tech/arc-host": "^0.5.8",
+    "@arcote.tech/arc-adapter-db-sqlite": "^0.5.8",
+    "@arcote.tech/platform": "^0.5.8",
     "@clack/prompts": "^0.9.0",
     "commander": "^11.1.0",
     "chokidar": "^3.5.3",

package/src/builder/build-cache.ts

@@ -0,0 +1,79 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const CACHE_VERSION = 1;
+const CACHE_FILE = ".build-cache.json";
+
+export interface CacheEntry {
+  inputHash: string;
+  outputHash?: string;
+  outputHashes?: Record<string, string>;
+}
+
+export interface BuildCache {
+  version: typeof CACHE_VERSION;
+  units: Record<string, CacheEntry>;
+}
+
+function emptyCache(): BuildCache {
+  return { version: CACHE_VERSION, units: {} };
+}
+
+/** Loads cache from .arc/platform/.build-cache.json. Returns empty cache on
+ *  missing file, parse error, or version mismatch. */
+export function loadBuildCache(arcDir: string): BuildCache {
+  const path = join(arcDir, CACHE_FILE);
+  if (!existsSync(path)) return emptyCache();
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    if (raw?.version !== CACHE_VERSION || typeof raw.units !== "object") {
+      return emptyCache();
+    }
+    return raw as BuildCache;
+  } catch {
+    return emptyCache();
+  }
+}
+
+export function saveBuildCache(arcDir: string, cache: BuildCache): void {
+  mkdirSync(arcDir, { recursive: true });
+  writeFileSync(
+    join(arcDir, CACHE_FILE),
+    JSON.stringify(cache, null, 2),
+  );
+}
+
+/** Cache hit = inputHash matches AND none of the required output paths are missing. */
+export function isCacheHit(
+  cache: BuildCache,
+  unitId: string,
+  inputHash: string,
+  requiredOutputs: readonly string[] = [],
+): boolean {
+  const entry = cache.units[unitId];
+  if (!entry || entry.inputHash !== inputHash) return false;
+  for (const out of requiredOutputs) {
+    if (!existsSync(out)) return false;
+  }
+  return true;
+}
+
+export function updateCache(
+  cache: BuildCache,
+  unitId: string,
+  inputHash: string,
+  output: { outputHash?: string; outputHashes?: Record<string, string> } = {},
+): void {
+  cache.units[unitId] = {
+    inputHash,
+    ...(output.outputHash !== undefined && { outputHash: output.outputHash }),
+    ...(output.outputHashes !== undefined && { outputHashes: output.outputHashes }),
+  };
+}
+
+export function getCachedEntry(
+  cache: BuildCache,
+  unitId: string,
+): CacheEntry | undefined {
+  return cache.units[unitId];
+}

package/src/builder/hash.ts

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative, sep } from "path";
+
+/** sha256 hex of bytes/string. Uses Bun.CryptoHasher. */
+export function sha256Hex(bytes: Uint8Array | ArrayBuffer | string): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(bytes as any);
+  return hasher.digest("hex");
+}
+
+/** Hash of concatenated file contents in stable sorted order. */
+export function sha256OfFiles(paths: readonly string[]): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  const sorted = [...paths].sort();
+  for (const p of sorted) {
+    if (!existsSync(p)) continue;
+    hasher.update(readFileSync(p));
+    hasher.update("\0");
+  }
+  return hasher.digest("hex");
+}
+
+/** Hash of a directory tree — content + relative path, deterministic.
+ *  filter receives POSIX-style relative paths (e.g. "src/index.ts").
+ *  Returns false from filter to skip a path; subdirs whose name is filtered
+ *  out are pruned entirely. */
+export function sha256OfDir(
+  dir: string,
+  filter?: (relPath: string) => boolean,
+): string {
+  if (!existsSync(dir)) return sha256Hex("");
+  const hasher = new Bun.CryptoHasher("sha256");
+  const entries: { rel: string; abs: string }[] = [];
+
+  function walk(absDir: string) {
+    for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+      const abs = join(absDir, entry.name);
+      const rel = relative(dir, abs).split(sep).join("/");
+      if (filter && !filter(rel)) continue;
+      if (entry.isDirectory()) walk(abs);
+      else if (entry.isFile()) entries.push({ rel, abs });
+    }
+  }
+
+  walk(dir);
+  entries.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+
+  for (const { rel, abs } of entries) {
+    hasher.update(rel);
+    hasher.update("\0");
+    hasher.update(readFileSync(abs));
+    hasher.update("\0");
+  }
+  return hasher.digest("hex");
+}
+
+/** Deterministic JSON hash — keys sorted recursively. */
+export function sha256OfJson(value: unknown): string {
+  return sha256Hex(stableStringify(value));
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  return (
+    "{" +
+    keys
+      .map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k]))
+      .join(",") +
+    "}"
+  );
+}
+
+/** Read installed version of a package from node_modules. Returns null if absent. */
+export function readInstalledVersion(
+  rootDir: string,
+  pkgName: string,
+): string | null {
+  const pkgJson = join(rootDir, "node_modules", pkgName, "package.json");
+  if (!existsSync(pkgJson)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgJson, "utf-8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** mtimeMs of a file/dir, or 0 if missing. Useful for asset cache keys. */
+export function mtimeOf(path: string): number {
+  if (!existsSync(path)) return 0;
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}