@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/index-22d57v4c.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  FileSys2
+} from "./index-5b6tavv3.js";
+import {
+  ConfigLock
+} from "./index-3hx1z96c.js";
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import dayjs from "dayjs";
+
+// pkgs/@akanjs/devkit/cloud/constants.ts
+import path from "path";
+var basePath = path.join(Bun.env.HOME ?? Bun.env.USERPROFILE ?? "", ".akan");
+var configPath = path.join(basePath, "config.json");
+var getDefaultHostConfig = (host = GlobalConfig.akanCloudHost) => ({ host });
+var defaultAkanGlobalConfig = {
+  cloudHost: {},
+  remoteEnvServers: {},
+  testTargets: {}
+};
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+class GlobalConfig {
+  static akanCloudHost = process.env.USE_AKANJS_PKGS === "true" ? `http://localhost:${process.env.CLOUD_HOST_PORT ?? 8283}` : "https://cloud.akanjs.com";
+  static async#getAkanGlobalConfig() {
+    const exists = await FileSys2.fileExists(configPath);
+    const akanConfig = exists ? await FileSys2.readJson(configPath) : {};
+    return {
+      ...defaultAkanGlobalConfig,
+      ...akanConfig,
+      cloudHost: akanConfig.cloudHost ?? defaultAkanGlobalConfig.cloudHost,
+      remoteEnvServers: akanConfig.remoteEnvServers ?? defaultAkanGlobalConfig.remoteEnvServers,
+      testTargets: akanConfig.testTargets ?? defaultAkanGlobalConfig.testTargets
+    };
+  }
+  static async#setAkanGlobalConfig(akanConfig) {
+    await mkdir(basePath, { recursive: true, mode: 448 });
+    const temp = `${configPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+      await writeFile(temp, JSON.stringify(akanConfig, null, 2), { mode: 384 });
+      await rename(temp, configPath);
+    } catch (error) {
+      await rm(temp, { force: true });
+      throw error;
+    }
+  }
+  static #lockPath = `${configPath}.lock`;
+  static async#update(mutate) {
+    await ConfigLock.run(GlobalConfig.#lockPath, async () => {
+      await GlobalConfig.#setAkanGlobalConfig(mutate(await GlobalConfig.#getAkanGlobalConfig()));
+    });
+  }
+  static async getHostConfig(host = GlobalConfig.akanCloudHost) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
+  }
+  static async setHostConfig(config = getDefaultHostConfig()) {
+    await GlobalConfig.#update((akanConfig) => GlobalConfig.#withHost(akanConfig, config));
+  }
+  static #withHost(akanConfig, config) {
+    return {
+      ...akanConfig,
+      cloudHost: { ...akanConfig.cloudHost, [config.host]: GlobalConfig.toHostConfigDto(config) }
+    };
+  }
+  static async refreshHostAuth(host, refresh) {
+    try {
+      return await ConfigLock.run(GlobalConfig.#lockPath, async () => {
+        const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+        const current = GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
+        const accessToken = current.auth?.accessToken;
+        const refreshToken = accessToken?.refreshToken;
+        if (!accessToken || !refreshToken || !GlobalConfig.needRefreshToken(accessToken))
+          return current;
+        const claimed = {
+          ...current,
+          auth: { ...current.auth, accessToken: { ...accessToken, refreshToken: null } }
+        };
+        await GlobalConfig.#setAkanGlobalConfig(GlobalConfig.#withHost(akanConfig, claimed));
+        const next = await refresh(refreshToken).catch(() => null);
+        if (!next?.jwt)
+          return claimed;
+        const refreshed = { ...current, auth: { ...current.auth, accessToken: next } };
+        await GlobalConfig.#setAkanGlobalConfig(GlobalConfig.#withHost(await GlobalConfig.#getAkanGlobalConfig(), refreshed));
+        return refreshed;
+      });
+    } catch {
+      return await GlobalConfig.getHostConfig(host);
+    }
+  }
+  static async getRemoteEnvServers() {
+    return (await GlobalConfig.#getAkanGlobalConfig()).remoteEnvServers;
+  }
+  static async setRemoteEnvServer(name, config) {
+    await GlobalConfig.#update((akanConfig) => ({
+      ...akanConfig,
+      remoteEnvServers: { ...akanConfig.remoteEnvServers, [name]: config }
+    }));
+  }
+  static async removeRemoteEnvServer(name) {
+    await GlobalConfig.#update((akanConfig) => {
+      const { [name]: _, ...remoteEnvServers } = akanConfig.remoteEnvServers;
+      return { ...akanConfig, remoteEnvServers };
+    });
+  }
+  static async getTestTargets() {
+    return (await GlobalConfig.#getAkanGlobalConfig()).testTargets;
+  }
+  static async setTestTargets(testTargets) {
+    await GlobalConfig.#update((akanConfig) => ({
+      ...akanConfig,
+      testTargets: { ...akanConfig.testTargets, ...testTargets }
+    }));
+  }
+  static needRefreshToken(accessToken) {
+    return !!accessToken?.expiresAt?.isBefore(dayjs().add(1, "hour"));
+  }
+  static toAccessToken(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt ? dayjs(accessToken.expiresAt) : null
+    };
+  }
+  static toAccessTokenDto(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt?.toString() ?? null
+    };
+  }
+  static toHostConfigDto(hostConfig) {
+    return {
+      host: hostConfig.host,
+      auth: {
+        accessToken: hostConfig.auth?.accessToken ? GlobalConfig.toAccessTokenDto(hostConfig.auth.accessToken) : undefined,
+        self: hostConfig.auth?.self
+      }
+    };
+  }
+  static toHostConfig(hostConfigDto) {
+    return {
+      host: hostConfigDto.host,
+      auth: {
+        accessToken: hostConfigDto.auth?.accessToken ? GlobalConfig.toAccessToken(hostConfigDto.auth.accessToken) : undefined,
+        self: hostConfigDto.auth?.self
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/cloud/cloudApi.ts
+class HttpClient {
+  baseUrl;
+  headers = {};
+  constructor(baseUrl, headers = {}) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  async get(url, { headers, signal } = {}) {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: { "Content-Type": "application/json", ...this.headers, ...headers },
+      ...signal ? { signal } : {}
+    });
+    return await HttpClient.#body(response, url);
+  }
+  async getFile(url, localPath, headers) {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: { ...this.headers, ...headers }
+    });
+    if (!response.ok)
+      throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    await Bun.write(localPath, response);
+  }
+  async post(url, data, { headers, signal } = {}) {
+    const isFormData = data instanceof FormData;
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      method: "POST",
+      body: isFormData ? data : JSON.stringify(data),
+      headers: isFormData ? { ...this.headers, ...headers } : { "Content-Type": "application/json", ...this.headers, ...headers },
+      ...signal ? { signal } : {}
+    });
+    return await HttpClient.#body(response, url);
+  }
+  static async#body(response, url) {
+    const text = await response.text();
+    if (!response.ok)
+      throw new Error(`${response.status} ${response.statusText} from ${url}: ${text.slice(0, 200)}`);
+    return JSON.parse(text);
+  }
+  setHeaders(headers) {
+    Object.assign(this.headers, headers);
+    return this;
+  }
+}
+
+class CloudApi {
+  #api;
+  #accessToken = null;
+  #workspace;
+  host;
+  url;
+  static async fromHost(workspace, host) {
+    const hostConfig = await GlobalConfig.getHostConfig(host);
+    const accessToken = hostConfig.auth?.accessToken;
+    if (!accessToken || !GlobalConfig.needRefreshToken(accessToken))
+      return new CloudApi(workspace, hostConfig);
+    const tokenless = new CloudApi(workspace, hostConfig);
+    const refreshed = await GlobalConfig.refreshHostAuth(hostConfig.host, (refreshToken) => tokenless.refreshAuthToken(refreshToken));
+    return new CloudApi(workspace, refreshed);
+  }
+  constructor(workspace, hostConfig) {
+    this.#workspace = workspace;
+    this.#accessToken = hostConfig.auth?.accessToken ?? null;
+    this.host = hostConfig.host;
+    this.url = `${this.host}/api`;
+    this.#api = new HttpClient(this.url);
+    if (this.#accessToken && !GlobalConfig.needRefreshToken(this.#accessToken))
+      this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+  }
+  #authorize(accessTokenDto) {
+    this.#accessToken = GlobalConfig.toAccessToken(accessTokenDto);
+    this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+    return this.#accessToken;
+  }
+  async uploadEnv(devProjectId, file) {
+    const formData = new FormData;
+    formData.append("devProjectId", devProjectId);
+    formData.append("file", file);
+    return await this.#api.post(`/uploadEnv/${devProjectId}`, formData);
+  }
+  async downloadEnv(devProjectId) {
+    const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;
+    await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
+    return localPath;
+  }
+  async getRemoteAuthToken(remoteId) {
+    try {
+      return this.#authorize(await this.#api.get(`/getRemoteAuthToken/${remoteId}`));
+    } catch (_) {
+      return null;
+    }
+  }
+  async refreshAuthToken(refreshToken) {
+    return this.#authorize(await this.#api.post(`/refreshAuthToken`, { refreshToken }, { signal: AbortSignal.timeout(20000) }));
+  }
+  async requestTunnel(input) {
+    return await this.#api.post(`/tunnel/requestTunnel`, input);
+  }
+  async tunnelListInSelf() {
+    return await this.#api.get(`/tunnel/tunnelListInSelf`);
+  }
+  async revokeTunnel(code) {
+    return await this.#api.post(`/tunnel/revokeTunnel`, { code }, { signal: AbortSignal.timeout(5000) });
+  }
+  async getRemoteSelf() {
+    try {
+      return await this.#api.get(`/getRemoteSelf`);
+    } catch {
+      return null;
+    }
+  }
+}
+export { getDefaultHostConfig, GlobalConfig, CloudApi };

package/{index-fz5q3gd7.js → index-31yr441d.js}

@@ -5,33 +5,26 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-gyd220p2.js";
+} from "./index-myhc3c1j.js";
 import {
   AkanContextAnalyzer
-} from "./index-ktb5njgy.js";
+} from "./index-ygn77a5w.js";
 import {
   runner
-} from "./index-mak3cd28.js";
+} from "./index-w2zdcw3k.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
-var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;
+var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {
+  cwd: workspace.workspaceRoot
+});
 var defaultExecutor = (workspace) => async (command) => {
+  const base = { command: command.command, reason: command.reason };
   try {
-    const stdout = await workspace.spawn("bash", ["-lc", commandForShell(command.command)], {
-      cwd: workspace.workspaceRoot
-    });
-    return {
-      command: command.command,
-      reason: command.reason,
-      status: "passed",
-      exitCode: 0,
-      stdout
-    };
+    return { ...base, status: "passed", exitCode: 0, stdout: await spawnShell(workspace, command.command) };
   } catch (error) {
     const commandError = error;
     return {
-      command: command.command,
-      reason: command.reason,
+      ...base,
       status: "failed",
       exitCode: commandError.code ?? 1,
       stdout: commandError.stdout,
@@ -158,4 +151,4 @@ class RepairRunner extends runner("repair") {
   }
 }
 
-export { RepairRunner };
+export { spawnShell, RepairRunner };

package/index-3hx1z96c.js

@@ -0,0 +1,87 @@
+// @bun
+// pkgs/@akanjs/devkit/cloud/configLock.ts
+import { mkdir, open, readFile, rm, stat } from "fs/promises";
+import path from "path";
+
+class ConfigLock {
+  static waitTimeoutMs = 30000;
+  static #unknownHolderStaleMs = 1e4;
+  static #pollMs = 50;
+  static async run(lockPath, fn) {
+    await mkdir(path.dirname(lockPath), { recursive: true, mode: 448 });
+    const deadline = Date.now() + ConfigLock.waitTimeoutMs;
+    while (!await ConfigLock.#take(lockPath)) {
+      if (Date.now() >= deadline) {
+        const holder = (await ConfigLock.#holder(lockPath))?.pid ?? "unknown";
+        throw new Error(`${lockPath} is held by process ${holder}; if no akan command is running, delete it and retry.`);
+      }
+      await ConfigLock.#reclaimIfAbandoned(lockPath);
+      await Bun.sleep(ConfigLock.#pollMs);
+    }
+    try {
+      return await fn();
+    } finally {
+      await rm(lockPath, { force: true });
+    }
+  }
+  static async#take(lockPath) {
+    const handle = await open(lockPath, "wx", 384).catch((error) => {
+      if (error.code === "EEXIST")
+        return null;
+      throw error;
+    });
+    if (!handle)
+      return false;
+    try {
+      await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }));
+    } finally {
+      await handle.close();
+    }
+    return true;
+  }
+  static async#reclaimIfAbandoned(lockPath) {
+    if (!await ConfigLock.#abandoned(lockPath))
+      return;
+    const guard = `${lockPath}.reclaim`;
+    if (!await ConfigLock.#take(guard)) {
+      if (await ConfigLock.#abandoned(guard))
+        await rm(guard, { force: true });
+      return;
+    }
+    try {
+      if (await ConfigLock.#abandoned(lockPath))
+        await rm(lockPath, { force: true });
+    } finally {
+      await rm(guard, { force: true });
+    }
+  }
+  static async#abandoned(lockPath) {
+    const info = await stat(lockPath).catch(() => null);
+    if (!info)
+      return false;
+    const holder = await ConfigLock.#holder(lockPath);
+    if (!holder)
+      return Date.now() - info.mtimeMs > ConfigLock.#unknownHolderStaleMs;
+    return !ConfigLock.#isAlive(holder.pid);
+  }
+  static async#holder(lockPath) {
+    try {
+      const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+      return typeof parsed.pid === "number" && typeof parsed.at === "number" ? { pid: parsed.pid, at: parsed.at } : null;
+    } catch {
+      return null;
+    }
+  }
+  static #isAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+      return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+}
+
+export { ConfigLock };

package/index-3sq321ak.js

@@ -0,0 +1,53 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-w2zdcw3k.js";
+import {
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  scalarChangedFiles
+} from "./index-myhc3c1j.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/scalar/scalar.runner.ts
+class ScalarRunner extends runner("scalar") {
+  async applyScalarTemplate(sys, scalarName) {
+    await sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: scalarName, models: pluralizeName(scalarName), sysName: sys.name },
+      overwrite: false
+    });
+    const read = async (suffix) => {
+      const filename = `${scalarName}.${suffix}`;
+      return { filename, content: await sys.readFile(`lib/__scalar/${scalarName}/${filename}`) };
+    };
+    return {
+      abstract: await read("abstract.md"),
+      constant: await read("constant.ts"),
+      dictionary: await read("dictionary.ts"),
+      document: await read("document.ts")
+    };
+  }
+}
+
+// pkgs/@akanjs/cli/scalar/scalar.script.ts
+class ScalarScript extends script("scalar", [ScalarRunner]) {
+  async createScalar(sys, scalarName) {
+    const files = await this.scalarRunner.applyScalarTemplate(sys, scalarName);
+    return createPassedPrimitiveReport({
+      command: "create-scalar",
+      changedFiles: scalarChangedFiles(sys, scalarName, files),
+      generatedFiles: generatedFilesForSync(sys),
+      target: sys.name
+    });
+  }
+  async removeScalar(sys, scalarName) {
+    await sys.removeDir(`lib/__scalar/${scalarName}`);
+  }
+}
+
+export { ScalarScript };

package/{index-kcxmv48c.js → index-3t7g9e4r.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
-  FileSys
-} from "./index-q0y2jq9j.js";
+  FileSys2
+} from "./index-5b6tavv3.js";
 
 // pkgs/@akanjs/devkit/dependencyScanner.ts
 import { builtinModules } from "module";
@@ -10,7 +10,10 @@ import ignore from "ignore";
 import ts from "typescript";
 var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
 var skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
-var isSkippedPath = (filePath) => skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
+var isSkippedPath = (filePath) => {
+  const posixPath = filePath.split(path.sep).join("/");
+  return skipDirs.some((dir) => posixPath.includes(`/${dir}/`) || posixPath.startsWith(`${dir}/`));
+};
 var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
@@ -54,24 +57,21 @@ class TypeScriptDependencyScanner2 {
   async getPackageBuildDependencies(projectName) {
     const runtimeDeps = new Set;
     const devDeps = new Set;
-    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
-      excludeBuildFiles: true,
-      excludeTestFiles: true
-    });
-    const cssFiles = await this.#findCssFiles(this.#directory);
+    const sourceFiles = await this.#findFiles("**/*.{ts,tsx}", { excludeBuildFiles: true, excludeTestFiles: true });
+    const cssFiles = await this.#findFiles("**/*.css");
     for (const filePath of sourceFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       this.#addNormalizedImports(runtimeDeps, imports, projectName);
       this.#addNormalizedImports(devDeps, typeImports, projectName);
     }
     for (const filePath of cssFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
     }
     const buildFilePath = path.join(this.#directory, "build.ts");
-    if (await FileSys.fileExists(buildFilePath)) {
-      const fileContent = await FileSys.readText(buildFilePath);
+    if (await FileSys2.fileExists(buildFilePath)) {
+      const fileContent = await FileSys2.readText(buildFilePath);
       const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
       this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
     }
@@ -95,7 +95,7 @@ class TypeScriptDependencyScanner2 {
     if (!await Bun.file(packageJsonPath).exists())
       return false;
     try {
-      const packageJson = await FileSys.readJson(packageJsonPath);
+      const packageJson = await FileSys2.readJson(packageJsonPath);
       return packageJson.name === dep && !!packageJson.version;
     } catch {
       return false;
@@ -106,27 +106,21 @@ class TypeScriptDependencyScanner2 {
     return this.#getImportSetsFromDependencies(depSets, fileDependencies);
   }
   #getImportSetsFromDependencies(depSets, fileDependencies) {
-    const importedDepSets = new Array(depSets.length);
-    for (let i = 0;i < depSets.length; i++)
-      importedDepSets[i] = new Set;
-    fileDependencies.forEach((imps) => {
-      imps.forEach((imp) => {
+    const importedDepSets = depSets.map(() => new Set);
+    for (const imps of fileDependencies.values())
+      for (const imp of imps) {
         if (imp.startsWith("."))
-          return;
-        const moduleName = imp;
-        const moduleNameParts = moduleName.split("/");
-        const subModuleLength = moduleNameParts.length;
-        for (let i = 0;i < subModuleLength; i++) {
-          const importName = moduleNameParts.slice(0, i + 1).join("/");
-          for (let j = 0;j < depSets.length; j++) {
-            if (depSets[j]?.has(importName)) {
-              importedDepSets[j]?.add(importName);
-              return;
-            }
-          }
+          continue;
+        const parts = imp.split("/");
+        for (let length = 1;length <= parts.length; length++) {
+          const importName = parts.slice(0, length).join("/");
+          const setIndex = depSets.findIndex((depSet) => depSet.has(importName));
+          if (setIndex === -1)
+            continue;
+          importedDepSets[setIndex]?.add(importName);
+          break;
         }
-      });
-    });
+      }
     return importedDepSets;
   }
   async getDependencies() {
@@ -134,43 +128,25 @@ class TypeScriptDependencyScanner2 {
     this.#fileRuntimeDependencies.clear();
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
-    const files = await this.#findTypeScriptFiles(this.#directory);
-    for (const file of files)
+    for (const file of await this.#findFiles("**/*.{ts,tsx}"))
       await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
-  async#findTypeScriptFiles(directory, {
+  async#findFiles(pattern, {
     excludeBuildFiles = false,
     excludeTestFiles = false
   } = {}) {
     const files = [];
-    const glob = new Bun.Glob("**/*.{ts,tsx}");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+    for await (const filePath of new Bun.Glob(pattern).scan({ cwd: this.#directory, onlyFiles: true })) {
       if (isSkippedPath(filePath))
         continue;
       if (excludeBuildFiles && filePath === "build.ts")
         continue;
       if (excludeTestFiles && testFileRegex.test(filePath))
         continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
-    }
-    return files;
-  }
-  async#findCssFiles(directory) {
-    const files = [];
-    const glob = new Bun.Glob("**/*.css");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (isSkippedPath(filePath))
-        continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
+      const fullPath = path.join(this.#directory, filePath);
+      if (!this.#ig.ignores(path.relative(this.#workspaceRoot, fullPath)))
+        files.push(fullPath);
     }
     return files;
   }
@@ -179,7 +155,7 @@ class TypeScriptDependencyScanner2 {
       return;
     this.#visitedFiles.add(filePath);
     try {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
       const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
@@ -191,19 +167,17 @@ class TypeScriptDependencyScanner2 {
   }
   async#resolveImports(imports, filePath, baseDir) {
     return await Promise.all(imports.map(async (importPath) => {
-      if (importPath.startsWith(".")) {
-        const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
-        return await this.#ensureExtension(resolvedPath);
-      }
-      return importPath;
+      if (!importPath.startsWith("."))
+        return importPath;
+      return await this.#ensureExtension(`./${path.join(path.relative(baseDir, filePath), importPath)}`);
     }));
   }
   async#ensureExtension(filePath) {
-    if (await FileSys.fileExists(`${filePath}.ts`))
+    if (await FileSys2.fileExists(`${filePath}.ts`))
       return `${filePath}.ts`;
-    else if (await FileSys.fileExists(`${filePath}.tsx`))
+    else if (await FileSys2.fileExists(`${filePath}.tsx`))
       return `${filePath}.tsx`;
-    else if (await FileSys.fileExists(filePath))
+    else if (await FileSys2.fileExists(filePath))
       return filePath;
     return `${filePath}.ts`;
   }
@@ -262,22 +236,14 @@ class TypeScriptDependencyScanner2 {
 `;
       const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
       const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
-      if (projectImports.length > 0) {
+      if (projectImports.length > 0)
         graph += `  Project dependencies:
-`;
-        projectImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
-      if (externalImports.length > 0) {
+${projectImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
+      if (externalImports.length > 0)
         graph += `  External dependencies:
-`;
-        externalImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
+${externalImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
       graph += `
 `;
     }