@awak-app/simy-cli 0.1.1 → 0.1.2

package/src/repository-inventory.js

@@ -0,0 +1,186 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, readdir, realpath, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+import { normalizeGitHubRemote } from "./workspace-context.js";
+
+const execFileAsync = promisify(execFile);
+const INVENTORY_VERSION = 1;
+const DEFAULT_MAX_DEPTH = 12;
+const DEFAULT_MAX_REPOSITORIES = 1_000;
+const SKIPPED_DIRECTORIES = new Set([
+  ".git",
+  ".cache",
+  ".npm",
+  ".pnpm-store",
+  ".Trash",
+  ".yarn",
+  "Library",
+  "node_modules",
+  "vendor",
+]);
+
+export function defaultRepositoryScanRoot() {
+  return homedir();
+}
+
+export function repositoryInventoryPath(inventoryRoot = defaultInventoryRoot()) {
+  return join(inventoryRoot, "repository-inventory.json");
+}
+
+export async function scanGitRepositories(
+  requestedRoot,
+  { maxDepth = DEFAULT_MAX_DEPTH, maxRepositories = DEFAULT_MAX_REPOSITORIES } = {},
+) {
+  const root = await realpath(resolve(String(requestedRoot || defaultRepositoryScanRoot())));
+  const repositories = [];
+  const visited = new Set();
+  const pending = [{ directory: root, depth: 0 }];
+
+  while (pending.length > 0 && repositories.length < maxRepositories) {
+    const current = pending.shift();
+    if (!current || visited.has(current.directory)) continue;
+    visited.add(current.directory);
+
+    let entries;
+    try {
+      entries = await readdir(current.directory, { withFileTypes: true });
+    } catch (error) {
+      if (isSkippableFilesystemError(error)) continue;
+      throw error;
+    }
+
+    if (entries.some((entry) => entry.name === ".git")) {
+      const repository = await inspectGitRepository(current.directory);
+      if (repository) repositories.push(repository);
+      continue;
+    }
+    if (current.depth >= maxDepth) continue;
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || shouldSkipDirectory(entry.name)) {
+        continue;
+      }
+      pending.push({
+        directory: join(current.directory, entry.name),
+        depth: current.depth + 1,
+      });
+    }
+  }
+
+  return {
+    root,
+    scannedAt: new Date().toISOString(),
+    repositories: mergeRepositoryInventory(repositories),
+    truncated: repositories.length >= maxRepositories,
+  };
+}
+
+export async function readRepositoryInventory(inventoryRoot = defaultInventoryRoot()) {
+  try {
+    const parsed = JSON.parse(await readFile(repositoryInventoryPath(inventoryRoot), "utf8"));
+    if (parsed?.version !== INVENTORY_VERSION) return emptyInventory();
+    return {
+      version: INVENTORY_VERSION,
+      authorizedRoots: uniqueStrings(parsed.authorized_roots),
+      repositories: mergeRepositoryInventory(parsed.repositories),
+      scannedAt: typeof parsed.scanned_at === "string" ? parsed.scanned_at : null,
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT" || error instanceof SyntaxError) return emptyInventory();
+    throw error;
+  }
+}
+
+export async function writeRepositoryInventory(
+  { authorizedRoots = [], repositories = [], scannedAt = new Date().toISOString() },
+  inventoryRoot = defaultInventoryRoot(),
+) {
+  const target = repositoryInventoryPath(inventoryRoot);
+  await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+  await writeFile(
+    target,
+    `${JSON.stringify(
+      {
+        version: INVENTORY_VERSION,
+        authorized_roots: uniqueStrings(authorizedRoots),
+        scanned_at: scannedAt,
+        repositories: mergeRepositoryInventory(repositories).map((item) => ({
+          repository: item.repository,
+          branch: item.branch,
+          local_path: item.local_path,
+        })),
+      },
+      null,
+      2,
+    )}\n`,
+    { encoding: "utf8", mode: 0o600 },
+  );
+}
+
+export function mergeRepositoryInventory(...inventories) {
+  const byPath = new Map();
+  for (const item of inventories.flat()) {
+    const repository = normalizeGitHubRemote(item?.repository);
+    const localPath = String(item?.local_path || item?.localPath || "").trim();
+    if (!repository || !localPath) continue;
+    byPath.set(resolve(localPath), {
+      repository,
+      branch: String(item?.branch || "").trim() || "dev",
+      local_path: resolve(localPath),
+    });
+  }
+  return [...byPath.values()].sort((left, right) =>
+    left.repository.localeCompare(right.repository),
+  );
+}
+
+export function findRepository(inventory, repository) {
+  const expected = normalizeGitHubRemote(repository)?.toLowerCase();
+  if (!expected) return null;
+  return (
+    inventory.find((item) => normalizeGitHubRemote(item?.repository)?.toLowerCase() === expected) ||
+    null
+  );
+}
+
+async function inspectGitRepository(directory) {
+  try {
+    const [{ stdout: root }, { stdout: remote }, { stdout: branch }] = await Promise.all([
+      execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd: directory }),
+      execFileAsync("git", ["remote", "get-url", "origin"], { cwd: directory }),
+      execFileAsync("git", ["branch", "--show-current"], { cwd: directory }),
+    ]);
+    const repository = normalizeGitHubRemote(remote);
+    if (!repository) return null;
+    return {
+      repository,
+      branch: String(branch || "").trim() || "dev",
+      local_path: String(root || "").trim(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkipDirectory(name) {
+  return name.startsWith(".") || SKIPPED_DIRECTORIES.has(name);
+}
+
+function isSkippableFilesystemError(error) {
+  return error?.code === "EACCES" || error?.code === "EPERM" || error?.code === "ENOENT";
+}
+
+function uniqueStrings(values) {
+  return [...new Set((Array.isArray(values) ? values : []).map(String).filter(Boolean))];
+}
+
+function emptyInventory() {
+  return { version: INVENTORY_VERSION, authorizedRoots: [], repositories: [], scannedAt: null };
+}
+
+function defaultInventoryRoot() {
+  return process.env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+}

package/src/run-registry.js

@@ -0,0 +1,44 @@
+import { EventEmitter } from "node:events";
+
+export class LocalRunRegistry extends EventEmitter {
+  #runs = new Map();
+  #listeners = new Map();
+
+  create(run) {
+    if (this.#runs.has(run.id)) throw new Error(`Run ${run.id} already exists.`);
+    this.#runs.set(run.id, run);
+    const listener = (event) => {
+      this.emit("event", { run, event });
+      this.emit("change", this.list());
+    };
+    this.#listeners.set(run.id, listener);
+    run.emitter.on("event", listener);
+    this.emit("event", { run, event: { type: "created", run_id: run.id } });
+    this.emit("change", this.list());
+    return run;
+  }
+
+  get(runId) {
+    return this.#runs.get(runId) ?? null;
+  }
+
+  has(runId) {
+    return this.#runs.has(runId);
+  }
+
+  list() {
+    return [...this.#runs.values()].sort((left, right) => {
+      const leftTime = Date.parse(left.snapshot?.updated_at || left.startedAt || 0) || 0;
+      const rightTime = Date.parse(right.snapshot?.updated_at || right.startedAt || 0) || 0;
+      return rightTime - leftTime;
+    });
+  }
+
+  close() {
+    for (const [runId, listener] of this.#listeners) {
+      this.#runs.get(runId)?.emitter.off("event", listener);
+    }
+    this.#listeners.clear();
+    this.removeAllListeners();
+  }
+}