agentplane 0.3.1 → 0.3.3

package/bin/runtime-context.js

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * @typedef {{
+ *   repoRoot: string;
+ *   packageRoot: string;
+ *   repoBin: string;
+ *   repoCli: string;
+ * }} FrameworkCheckout
+ */
+
+/**
+ * @typedef {{
+ *   cwd: string;
+ *   thisBin: string;
+ * }} FrameworkBinaryContextOptions
+ */
+
+/**
+ * @typedef {{
+ *   inFrameworkCheckout: boolean;
+ *   isRepoLocalBinary: boolean;
+ *   isRepoLocalRuntime: boolean;
+ *   checkout: FrameworkCheckout | null;
+ *   thisBin: string;
+ * }} FrameworkBinaryContext
+ */
+
+function fileExists(p) {
+  return existsSync(p);
+}
+
+/**
+ * @param {string} startDir
+ * @returns {FrameworkCheckout | null}
+ */
+export function findFrameworkCheckout(startDir) {
+  let dir = path.resolve(startDir);
+  for (;;) {
+    const packageRoot = path.join(dir, "packages", "agentplane");
+    const repoBin = path.join(packageRoot, "bin", "agentplane.js");
+    const repoCli = path.join(packageRoot, "src", "cli.ts");
+    if (fileExists(repoBin) && fileExists(repoCli)) {
+      return {
+        repoRoot: dir,
+        packageRoot,
+        repoBin,
+        repoCli,
+      };
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * @param {string} baseDir
+ * @param {string} targetPath
+ * @returns {boolean}
+ */
+export function isPathInside(baseDir, targetPath) {
+  const rel = path.relative(path.resolve(baseDir), path.resolve(targetPath));
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+/**
+ * @param {FrameworkBinaryContextOptions} options
+ * @returns {FrameworkBinaryContext}
+ */
+export function resolveFrameworkBinaryContext(options) {
+  const cwd = path.resolve(options.cwd);
+  const thisBin = path.resolve(options.thisBin);
+  const checkout = findFrameworkCheckout(cwd);
+  if (!checkout) {
+    return {
+      inFrameworkCheckout: false,
+      isRepoLocalBinary: false,
+      isRepoLocalRuntime: false,
+      checkout: null,
+      thisBin,
+    };
+  }
+
+  return {
+    inFrameworkCheckout: true,
+    isRepoLocalBinary: path.resolve(checkout.repoBin) === thisBin,
+    isRepoLocalRuntime: isPathInside(checkout.packageRoot, thisBin),
+    checkout,
+    thisBin,
+  };
+}

package/bin/runtime-watch.d.ts

@@ -0,0 +1,26 @@
+export type WatchedRuntimeSnapshotFile = {
+  path: string;
+  sha256: string;
+  size_bytes: number;
+};
+
+export type WatchedRuntimeSnapshot = {
+  watchedPaths: string[];
+  files: WatchedRuntimeSnapshotFile[];
+  snapshotHash: string;
+};
+
+export type WatchedRuntimeSnapshotComparison = {
+  ok: boolean;
+  changedPaths: string[];
+};
+
+export function getWatchedRuntimePathsForPackage(packageName: string): string[];
+export function collectWatchedRuntimeSnapshot(
+  packageDir: string,
+  watchedPaths: string[],
+): Promise<WatchedRuntimeSnapshot>;
+export function compareWatchedRuntimeSnapshots(
+  recordedSnapshot: WatchedRuntimeSnapshot,
+  currentSnapshot: WatchedRuntimeSnapshot,
+): WatchedRuntimeSnapshotComparison;

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" };
+}