@akanjs/cli 2.4.1-rc.3 → 2.4.1-rc.4

package/index-0fn1r7gg.js

@@ -0,0 +1,466 @@
+// @bun
+// pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
+import fs from "fs";
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
+import path from "path";
+var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var CSS_EXTS = new Set([".css"]);
+var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+
+class HmrChangeClassifier {
+  classify(abs) {
+    if (this.#isUninteresting(abs))
+      return "ignore";
+    const base = path.basename(abs);
+    if (CONFIG_BASENAMES.has(base))
+      return "config";
+    const ext = path.extname(abs).toLowerCase();
+    if (CSS_EXTS.has(ext))
+      return "css";
+    if (SOURCE_EXTS.has(ext))
+      return "code";
+    return "ignore";
+  }
+  #isUninteresting(abs) {
+    const base = path.basename(abs);
+    if (!base)
+      return true;
+    if (base.startsWith("."))
+      return true;
+    if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx") || base.endsWith(".tmp"))
+      return true;
+    if (abs.includes(`${path.sep}node_modules${path.sep}`))
+      return true;
+    if (abs.includes(`${path.sep}.akan${path.sep}`))
+      return true;
+    return false;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/sourceMtimeIndex.ts
+import { readdir, stat } from "fs/promises";
+import path2 from "path";
+var UNREADABLE = Number.NaN;
+
+class SourceMtimeIndex {
+  #roots;
+  #classifier;
+  #files = new Map;
+  #dirs = new Map;
+  #unreadable = new Map;
+  #primed = false;
+  #queue = Promise.resolve();
+  constructor({ roots, classifier }) {
+    this.#roots = SourceMtimeIndex.#pruneNestedRoots(roots);
+    this.#classifier = classifier ?? new HmrChangeClassifier;
+  }
+  get primed() {
+    return this.#primed;
+  }
+  get trackedFileCount() {
+    return this.#files.size;
+  }
+  get coverageGaps() {
+    return [...this.#unreadable].map(([file, code]) => ({ path: file, code }));
+  }
+  async prime() {
+    await this.#serialize(async () => {
+      this.#files.clear();
+      this.#dirs.clear();
+      this.#unreadable.clear();
+      await Promise.all(this.#roots.map((root) => this.#walk(root, null)));
+      this.#primed = true;
+    });
+  }
+  async collectChanges() {
+    return this.#serialize(async () => {
+      if (!this.#primed)
+        return [];
+      const changed = new Set;
+      await this.#collectFileChanges(changed);
+      await this.#collectDirChanges(changed);
+      return [...changed];
+    });
+  }
+  async#serialize(work) {
+    const run = this.#queue.then(work, work);
+    this.#queue = run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  async absorb(paths) {
+    await this.#serialize(async () => {
+      if (!this.#primed)
+        return;
+      await Promise.all(paths.map(async (file) => {
+        const abs = path2.resolve(file);
+        const stats = await stat(abs).catch(() => null);
+        if (!stats?.isFile()) {
+          this.#files.delete(abs);
+          return;
+        }
+        this.#files.set(abs, { mtimeMs: stats.mtimeMs, size: stats.size });
+      }));
+    });
+  }
+  async#collectFileChanges(changed) {
+    await Promise.all([...this.#files.keys()].map(async (abs) => {
+      const { stats, err } = await SourceMtimeIndex.#statPath(abs);
+      if (!stats) {
+        if (err && !SourceMtimeIndex.#isMissing(err)) {
+          this.#unreadable.set(abs, err.code ?? "EUNKNOWN");
+          return;
+        }
+        this.#files.delete(abs);
+        this.#unreadable.delete(abs);
+        changed.add(abs);
+        return;
+      }
+      this.#unreadable.delete(abs);
+      if (!stats.isFile()) {
+        this.#files.delete(abs);
+        changed.add(abs);
+        return;
+      }
+      const known = this.#files.get(abs);
+      if (known && known.mtimeMs === stats.mtimeMs && known.size === stats.size)
+        return;
+      this.#files.set(abs, { mtimeMs: stats.mtimeMs, size: stats.size });
+      changed.add(abs);
+    }));
+  }
+  async#collectDirChanges(changed) {
+    const moved = [];
+    const gone = [];
+    await Promise.all([...this.#dirs.entries()].map(async ([dir, mtimeMs]) => {
+      const { stats, err } = await SourceMtimeIndex.#statPath(dir);
+      if (!stats?.isDirectory()) {
+        if (err && !SourceMtimeIndex.#isMissing(err)) {
+          this.#markUnreadable(dir, err);
+          return;
+        }
+        gone.push(dir);
+        return;
+      }
+      if (stats.mtimeMs !== mtimeMs)
+        moved.push(dir);
+    }));
+    for (const dir of gone)
+      this.#forget(dir);
+    for (const dir of moved)
+      await this.#walk(dir, changed);
+  }
+  async#walk(dir, changed) {
+    const [listing, dirStat] = await Promise.all([SourceMtimeIndex.#readdirPath(dir), SourceMtimeIndex.#statPath(dir)]);
+    const entries = listing.entries;
+    const dirStats = dirStat.stats;
+    if (!entries || !dirStats?.isDirectory()) {
+      const err = listing.err ?? dirStat.err;
+      if (err && !SourceMtimeIndex.#isMissing(err)) {
+        this.#markUnreadable(dir, err);
+        return;
+      }
+      this.#forget(dir);
+      return;
+    }
+    const known = this.#dirs.has(dir);
+    this.#dirs.set(dir, dirStats.mtimeMs);
+    this.#unreadable.delete(dir);
+    const descend = [];
+    const present = new Set;
+    let blind = false;
+    for (const entry of entries) {
+      if (SourceMtimeIndex.#skipDirent(entry.name))
+        continue;
+      const abs = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        descend.push(abs);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (this.#classifier.classify(abs) === "ignore")
+        continue;
+      present.add(abs);
+      const { stats, err } = await SourceMtimeIndex.#statPath(abs);
+      if (!stats?.isFile()) {
+        if (err && !SourceMtimeIndex.#isMissing(err)) {
+          this.#unreadable.set(abs, err.code ?? "EUNKNOWN");
+          blind = true;
+        }
+        continue;
+      }
+      this.#unreadable.delete(abs);
+      const previous = this.#files.get(abs);
+      if (previous && previous.mtimeMs === stats.mtimeMs && previous.size === stats.size)
+        continue;
+      this.#files.set(abs, { mtimeMs: stats.mtimeMs, size: stats.size });
+      changed?.add(abs);
+    }
+    if (known) {
+      for (const abs of [...this.#files.keys()]) {
+        if (present.has(abs) || path2.dirname(abs) !== dir)
+          continue;
+        this.#files.delete(abs);
+        changed?.add(abs);
+      }
+    }
+    if (blind)
+      this.#dirs.set(dir, UNREADABLE);
+    await Promise.all(descend.filter((sub) => !this.#dirs.has(sub)).map((sub) => this.#walk(sub, changed)));
+  }
+  #markUnreadable(dir, err) {
+    this.#dirs.set(dir, UNREADABLE);
+    this.#unreadable.set(dir, err.code ?? "EUNKNOWN");
+  }
+  #forget(dir) {
+    const prefix = `${dir}${path2.sep}`;
+    this.#dirs.delete(dir);
+    this.#unreadable.delete(dir);
+    for (const known of [...this.#dirs.keys()])
+      if (known.startsWith(prefix))
+        this.#dirs.delete(known);
+    for (const known of [...this.#unreadable.keys()])
+      if (known.startsWith(prefix))
+        this.#unreadable.delete(known);
+  }
+  static async#statPath(abs) {
+    try {
+      return { stats: await stat(abs), err: null };
+    } catch (err) {
+      return { stats: null, err };
+    }
+  }
+  static async#readdirPath(dir) {
+    try {
+      return { entries: await readdir(dir, { withFileTypes: true }), err: null };
+    } catch (err) {
+      return { entries: null, err };
+    }
+  }
+  static #isMissing(err) {
+    return err.code === "ENOENT" || err.code === "ENOTDIR";
+  }
+  static #skipDirent(name) {
+    return !name || name.startsWith(".") || name === "node_modules";
+  }
+  static #pruneNestedRoots(roots) {
+    const resolved = [...new Set(roots.map((root) => path2.resolve(root)))].sort();
+    return resolved.filter((root) => !resolved.some((other) => other !== root && root.startsWith(`${other}${path2.sep}`)));
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
+class HmrWatcher {
+  #roots;
+  #debounceMs;
+  #verifyDelayMs;
+  #onBatch;
+  #logger;
+  #watchers = [];
+  #pending = new Map;
+  #hinted = new Set;
+  #classifier = new HmrChangeClassifier;
+  #index;
+  #timer = null;
+  #verifyTimer = null;
+  #stopped = false;
+  #flushing = false;
+  #unreportedChanges = 0;
+  #reportedCompensating = false;
+  #reportedGaps = "";
+  constructor(opts) {
+    this.#roots = [...new Set(opts.roots.map((r) => path3.resolve(r)))];
+    this.#debounceMs = opts.debounceMs ?? 80;
+    this.#verifyDelayMs = opts.verifyDelayMs ?? 250;
+    this.#onBatch = opts.onBatch;
+    this.#logger = opts.logger;
+    this.#index = new SourceMtimeIndex({ roots: this.#roots, classifier: this.#classifier });
+  }
+  get unreportedChanges() {
+    return this.#unreportedChanges;
+  }
+  async start() {
+    for (const root of this.#roots) {
+      try {
+        const w = fs.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
+          if (!filename)
+            return;
+          const abs = path3.resolve(root, filename.toString());
+          this.#queue(abs);
+        });
+        this.#watchers.push(w);
+        this.#logger.verbose(`[hmr] watching ${root}`);
+      } catch (err) {
+        this.#logger.error(`[hmr] failed to watch ${root}: ${err.message}`);
+      }
+    }
+    try {
+      await this.#index.prime();
+      this.#reportCoverageGaps();
+      this.#logger.verbose(`[hmr] tracking ${this.#index.trackedFileCount} source files for change verification`);
+    } catch (err) {
+      this.#logger.error(`[hmr] mtime index unavailable; falling back to watcher events alone, which drop concurrent saves: ${err.message}`);
+    }
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    if (this.#verifyTimer)
+      clearTimeout(this.#verifyTimer);
+    for (const w of this.#watchers) {
+      try {
+        w.close();
+      } catch {}
+    }
+  }
+  async absorb(paths) {
+    if (paths.length === 0)
+      return;
+    await this.#index.absorb(paths);
+  }
+  #queue(abs) {
+    const kind = this.#classifier.classify(abs);
+    if (!this.#index.primed) {
+      if (kind === "ignore")
+        return;
+      this.#pending.set(abs, kind);
+      this.#scheduleFlush();
+      return;
+    }
+    if (kind === "ignore") {
+      this.#scheduleVerify();
+      return;
+    }
+    this.#hinted.add(abs);
+    this.#scheduleFlush();
+  }
+  #scheduleFlush() {
+    if (this.#flushing)
+      return;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = setTimeout(() => this.#flush(), this.#debounceMs);
+  }
+  #flush() {
+    this.#timer = null;
+    if (this.#stopped || this.#flushing)
+      return;
+    this.#drain();
+  }
+  async#drain() {
+    this.#flushing = true;
+    try {
+      while (!this.#stopped) {
+        await this.#mergeDetectedChanges();
+        if (this.#pending.size === 0)
+          break;
+        const files = Array.from(this.#pending.keys());
+        const kinds = new Set(this.#pending.values());
+        this.#pending.clear();
+        this.#hinted.clear();
+        try {
+          await this.#onBatch({ files, kinds });
+        } catch (e) {
+          this.#logger.error(`[hmr] onBatch error: ${e.message}`);
+        }
+      }
+    } finally {
+      this.#flushing = false;
+      if (!this.#stopped && this.#pending.size > 0)
+        this.#timer = setTimeout(() => this.#flush(), this.#debounceMs);
+      else
+        this.#scheduleVerify();
+    }
+  }
+  async#mergeDetectedChanges() {
+    const detected = await this.#index.collectChanges().catch((err) => {
+      this.#logger.error(`[hmr] mtime scan failed: ${err.message}`);
+      return [];
+    });
+    this.#reportCoverageGaps();
+    let unreported = 0;
+    for (const abs of detected) {
+      const kind = this.#classifier.classify(abs);
+      if (kind === "ignore")
+        continue;
+      if (!this.#hinted.has(abs))
+        unreported += 1;
+      this.#pending.set(abs, kind);
+    }
+    if (unreported === 0)
+      return;
+    this.#unreportedChanges += unreported;
+    if (!this.#reportedCompensating) {
+      this.#reportedCompensating = true;
+      this.#logger.info(`[hmr] recovered ${unreported} change(s) that fs.watch did not report; Bun coalesces concurrent saves and drops all but one, so changes are resolved by mtime`);
+    }
+    this.#logger.verbose(`[hmr] mtime scan found ${unreported} change(s) fs.watch never reported (${this.#unreportedChanges} total)`);
+  }
+  #reportCoverageGaps() {
+    const gaps = this.#index.coverageGaps;
+    const key = gaps.map((gap) => `${gap.code}:${gap.path}`).sort().join("|");
+    if (key === this.#reportedGaps)
+      return;
+    this.#reportedGaps = key;
+    if (gaps.length === 0) {
+      this.#logger.info("[hmr] all watch roots readable again; change detection is complete");
+      return;
+    }
+    const shown = gaps.slice(0, 3).map((gap) => `${gap.path} (${gap.code})`).join(", ");
+    const rest = gaps.length > 3 ? ` and ${gaps.length - 3} more` : "";
+    this.#logger.warn(`[hmr] cannot read ${gaps.length} path(s), so edits underneath them will not rebuild: ${shown}${rest}`);
+  }
+  #scheduleVerify() {
+    if (this.#stopped || this.#verifyDelayMs <= 0)
+      return;
+    if (this.#verifyTimer)
+      clearTimeout(this.#verifyTimer);
+    this.#verifyTimer = setTimeout(() => {
+      this.#verifyTimer = null;
+      this.#verify();
+    }, this.#verifyDelayMs);
+  }
+  async#verify() {
+    if (this.#stopped || this.#flushing)
+      return;
+    await this.#mergeDetectedChanges();
+    if (this.#pending.size > 0)
+      await this.#drain();
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
+import fs2 from "fs";
+import path4 from "path";
+
+class WatchRootResolver {
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  async resolve() {
+    const tsconfig = await this.#app.getTsConfig();
+    const set = new Set;
+    set.add(path4.resolve(`${this.#app.cwdPath}/page`));
+    for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
+      for (const target of targets) {
+        if (!target)
+          continue;
+        if (path4.isAbsolute(target))
+          continue;
+        const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
+        const resolved = path4.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        if (fs2.existsSync(resolved))
+          set.add(resolved);
+      }
+    }
+    return [...set];
+  }
+}
+
+export { HmrWatcher, WatchRootResolver };

package/{index-1fpjvqhs.js → index-0jwvs8vp.js}

@@ -1,22 +1,22 @@
 // @bun
 import {
   RepairRunner
-} from "./index-85msc0wg.js";
+} from "./index-jbtn8h1y.js";
 import {
   WorkflowRunner
-} from "./index-45aj5ry0.js";
+} from "./index-3sd2vape.js";
 import {
   ScalarScript
-} from "./index-gb26e7z0.js";
+} from "./index-ahpcr9ss.js";
 import {
   PrimitiveScript
-} from "./index-m9pca6jv.js";
+} from "./index-2v6a4wd5.js";
 import {
   ModuleScript
-} from "./index-fmky5k3p.js";
+} from "./index-wh201a76.js";
 import {
   isPlaceholderAppId
-} from "./index-1xdrsbry.js";
+} from "./index-hk58kr1m.js";
 import {
   AkanContextAnalyzer,
   akanMcpInstallConfigPaths,
@@ -27,17 +27,17 @@ import {
   renderDoctorText,
   resourceList,
   upsertCodexMcpServerBlock
-} from "./index-8rc0bm04.js";
+} from "./index-eay4t1te.js";
 import {
   buildAkanModuleContextIndex,
   createWorkflowBaselineSummary,
   createWorkflowStepRegistry,
   jsonText,
   toolingRolloutGate
-} from "./index-h6ca6qg0.js";
+} from "./index-2v10yr8g.js";
 import {
   Prompter
-} from "./index-qaq13qk3.js";
+} from "./index-eqxmxan6.js";
 import {
   getMobileTargets
 } from "./index-76rn3g2c.js";
@@ -45,10 +45,10 @@ import {
   CommandContainer,
   runner,
   script
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 import {
   AppExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/cli/context/context.script.ts
 import { Logger } from "akanjs/common";

package/{index-a6sbyy0b.js → index-0t7pwff2.js}

@@ -2369,6 +2369,9 @@ class AppExecutor extends SysExecutor {
     return WorkspaceExecutor.getBaseDevEnv().env;
   }
   async getDevPort() {
+    const pinned = Number(process.env.AKAN_DEV_PORT);
+    if (Number.isInteger(pinned) && pinned > 0 && pinned <= 65535)
+      return pinned;
     const basePort = 8282;
     const appNames = (await this.workspace.getApps()).sort((a, b) => a.localeCompare(b));
     const appIndex = Math.max(appNames.indexOf(this.name), 0);

package/{index-h6ca6qg0.js → index-2v10yr8g.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `

package/{index-m9pca6jv.js → index-2v6a4wd5.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   ModuleScript
-} from "./index-fmky5k3p.js";
+} from "./index-wh201a76.js";
 import {
   addFieldUiPolicyForType,
   coerceFieldDefault,
@@ -34,15 +34,15 @@ import {
   sourceFile,
   validationCommandsForTarget,
   viaBuilderParameterName
-} from "./index-h6ca6qg0.js";
+} from "./index-2v10yr8g.js";
 import {
   script
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
 import { capitalize } from "akanjs/common";

package/{index-45aj5ry0.js → index-3sd2vape.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AkanContextAnalyzer
-} from "./index-8rc0bm04.js";
+} from "./index-eay4t1te.js";
 import {
   WorkflowExecutor,
   compactWorkflowInputs,
@@ -23,10 +23,10 @@ import {
   workflowCommandsForPlan,
   workflowPlanApproval,
   writeWorkflowRunArtifact
-} from "./index-h6ca6qg0.js";
+} from "./index-2v10yr8g.js";
 import {
   runner
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
 import { mkdir, readFile, writeFile } from "fs/promises";

package/{index-gb26e7z0.js → index-ahpcr9ss.js}

@@ -6,17 +6,17 @@ import {
   createPassedPrimitiveReport,
   generatedFilesForSync,
   scalarChangedFiles
-} from "./index-h6ca6qg0.js";
+} from "./index-2v10yr8g.js";
 import {
   Prompter
-} from "./index-qaq13qk3.js";
+} from "./index-eqxmxan6.js";
 import {
   AiSession
 } from "./index-5vvwc0cz.js";
 import {
   runner,
   script
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 
 // pkgs/@akanjs/cli/scalar/scalar.prompt.ts
 import { input } from "@inquirer/prompts";

package/{index-8rc0bm04.js → index-eay4t1te.js}

@@ -2,11 +2,11 @@
 import {
   workflowRunArtifactPath,
   workflowSyncDir
-} from "./index-h6ca6qg0.js";
+} from "./index-2v10yr8g.js";
 import {
   AppExecutor,
   LibExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 import {
   FileSys
 } from "./index-61keag0s.js";

package/{index-qaq13qk3.js → index-eqxmxan6.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   getDirname
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/devkit/prompter.ts
 import fsPromise from "fs/promises";

package/{index-pmm9e2jf.js → index-fh990y67.js}

@@ -2,10 +2,10 @@
 import {
   runner,
   script
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 import {
   LibExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/cli/semver.ts
 function parseVersion(version) {

package/{index-dynknvzd.js → index-gr4cjv99.js}

@@ -7,14 +7,14 @@ import {
 } from "./index-5vvwc0cz.js";
 import {
   openBrowser
-} from "./index-rgfxj6qc.js";
+} from "./index-n5y2gbf2.js";
 import {
   runner
-} from "./index-hdqztm58.js";
+} from "./index-qpz4csbs.js";
 import {
   AppExecutor,
   WorkspaceExecutor
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
 import path from "path";

package/{index-1xdrsbry.js → index-hk58kr1m.js}

@@ -5,7 +5,7 @@ import {
 } from "./index-76rn3g2c.js";
 import {
   CommandExecutionError
-} from "./index-a6sbyy0b.js";
+} from "./index-0t7pwff2.js";
 
 // pkgs/@akanjs/devkit/capacitorApp.ts
 import { cp, mkdir, readFile, rm, writeFile } from "fs/promises";