agentplane 0.3.2 → 0.3.3

package/bin/runtime-watch.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+const WATCHED_RUNTIME_PATHS = {
+  agentplane: [
+    "src",
+    "bin/agentplane.js",
+    "bin/dist-guard.js",
+    "bin/runtime-context.js",
+    "bin/stale-dist-policy.js",
+  ],
+  "@agentplaneorg/core": ["src"],
+};
+
+function normalizePath(value) {
+  return value.split(path.sep).join("/");
+}
+
+async function exists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function walkFiles(targetPath) {
+  const targetStat = await stat(targetPath);
+  if (targetStat.isFile()) return [targetPath];
+  if (!targetStat.isDirectory()) return [];
+
+  const entries = await readdir(targetPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+    const childPath = path.join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await walkFiles(childPath)));
+      continue;
+    }
+    if (entry.isFile()) files.push(childPath);
+  }
+  return files;
+}
+
+function fileHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+function snapshotHash(files) {
+  const digest = createHash("sha256");
+  for (const file of files) {
+    digest.update(file.path);
+    digest.update(":");
+    digest.update(file.sha256);
+    digest.update("\n");
+  }
+  return digest.digest("hex");
+}
+
+export function getWatchedRuntimePathsForPackage(packageName) {
+  return [...(WATCHED_RUNTIME_PATHS[packageName] ?? ["src"])];
+}
+
+export async function collectWatchedRuntimeSnapshot(packageDir, watchedPaths) {
+  const normalizedWatchedPaths = [...new Set(watchedPaths.map((entry) => normalizePath(entry)))];
+
+  const absoluteFiles = [];
+  for (const watchedPath of normalizedWatchedPaths) {
+    const absolutePath = path.join(packageDir, watchedPath);
+    if (!(await exists(absolutePath))) continue;
+    absoluteFiles.push(...(await walkFiles(absolutePath)));
+  }
+
+  const uniqueAbsoluteFiles = [...new Set(absoluteFiles)].toSorted((a, b) => a.localeCompare(b));
+  const files = [];
+  for (const absolutePath of uniqueAbsoluteFiles) {
+    const content = await readFile(absolutePath);
+    files.push({
+      path: normalizePath(path.relative(packageDir, absolutePath)),
+      sha256: fileHash(content),
+      size_bytes: content.byteLength,
+    });
+  }
+
+  return {
+    watchedPaths: normalizedWatchedPaths,
+    files,
+    snapshotHash: snapshotHash(files),
+  };
+}
+
+function snapshotFileMap(snapshot) {
+  return new Map(snapshot.files.map((file) => [file.path, file.sha256]));
+}
+
+export function compareWatchedRuntimeSnapshots(recordedSnapshot, currentSnapshot) {
+  if (
+    recordedSnapshot.snapshotHash === currentSnapshot.snapshotHash &&
+    recordedSnapshot.files.length === currentSnapshot.files.length
+  ) {
+    return { ok: true, changedPaths: [] };
+  }
+
+  const recordedMap = snapshotFileMap(recordedSnapshot);
+  const currentMap = snapshotFileMap(currentSnapshot);
+  const changedPaths = [...new Set([...recordedMap.keys(), ...currentMap.keys()])]
+    .filter((filePath) => recordedMap.get(filePath) !== currentMap.get(filePath))
+    .toSorted((a, b) => a.localeCompare(b));
+
+  return {
+    ok: changedPaths.length === 0,
+    changedPaths,
+  };
+}

package/bin/stale-dist-policy.d.ts

@@ -0,0 +1,6 @@
+export type StaleDistPolicy = {
+  mode: "warn_and_run" | "strict";
+  reason: "read_only_diagnostic" | "default";
+};
+
+export function classifyStaleDistPolicy(argv?: string[]): StaleDistPolicy;

package/bin/stale-dist-policy.js

@@ -0,0 +1,44 @@
+function normalizeArgs(argv) {
+  return argv
+    .slice(2)
+    .map((value) => String(value ?? "").trim())
+    .filter(Boolean);
+}
+
+function isHelpOrVersionCommand(args) {
+  return (
+    args.length === 0 ||
+    args[0] === "--help" ||
+    args[0] === "-h" ||
+    args[0] === "--version" ||
+    args[0] === "-v" ||
+    args[0] === "help"
+  );
+}
+
+function isConfigInspectionCommand(args) {
+  return args[0] === "config" && args[1] === "show";
+}
+
+function isTaskInspectionCommand(args) {
+  return args[0] === "task" && ["list", "show", "verify-show"].includes(args[1] ?? "");
+}
+
+function isRoleOrQuickstartCommand(args) {
+  return args[0] === "quickstart" || args[0] === "role";
+}
+
+export function classifyStaleDistPolicy(argv = process.argv) {
+  const args = normalizeArgs(argv);
+  if (
+    args[0] === "doctor" ||
+    (args[0] === "runtime" && args[1] === "explain") ||
+    isHelpOrVersionCommand(args) ||
+    isRoleOrQuickstartCommand(args) ||
+    isConfigInspectionCommand(args) ||
+    isTaskInspectionCommand(args)
+  ) {
+    return { mode: "warn_and_run", reason: "read_only_diagnostic" };
+  }
+  return { mode: "strict", reason: "default" };
+}