@jstn-sdk/ma 0.1.12 → 0.14.0

package/src/runtime/pi-maestro-core.js

@@ -0,0 +1,89 @@
+export function isPiMaestroEnabled(env = process.env) {
+  return env.MA_MAESTRO_PI === "1";
+}
+
+export function assertPiMaestroToolAllowed(
+  name,
+  { controlPlaneReady = true, buildReadiness } = {},
+) {
+  if (!controlPlaneReady) throw new Error(`${name} blocked by control-plane readiness`);
+  if (name === "$build" && buildReadiness && buildReadiness.allowed !== true) {
+    throw new Error(
+      `$build blocked: ${(buildReadiness.blockers ?? []).join("; ") || "readiness failed"}`,
+    );
+  }
+}
+
+export function createPiMaestroToolSurface({
+  runners = {},
+  controlPlaneReady = true,
+  buildReadiness,
+  beforeToolCall,
+  afterToolCall,
+  isWaitingReview = () => false,
+} = {}) {
+  const surface = {
+    tools: {},
+    async dispatch(name, input = {}) {
+      if (!runners[name]) throw new Error(`Unknown pi-maestro tool: ${name}`);
+      if (isWaitingReview()) return { terminate: true, status: "WAITING_REVIEW" };
+      assertPiMaestroToolAllowed(name, { controlPlaneReady, buildReadiness });
+      await beforeToolCall?.(name, input);
+      const result = await runners[name](input);
+      await afterToolCall?.(name, result);
+      return { terminate: false, result };
+    },
+  };
+  surface.tools = Object.fromEntries(
+    Object.keys(runners).map((name) => [
+      name,
+      {
+        name,
+        description: `Run the bounded ${name} Meta-Architect lane`,
+        execute: (input) => surface.dispatch(name, input),
+      },
+    ]),
+  );
+  return surface;
+}
+
+export const maestroGateLanes = ["$arch", "$sage", "$flow", "$vet", "$vibe", "$build"];
+
+export function createPiMaestroCapabilityMapping({
+  runners = {},
+  enabled = isPiMaestroEnabled(),
+  ...options
+} = {}) {
+  const laneRunners = Object.fromEntries(
+    maestroGateLanes
+      .filter((lane) => typeof runners[lane] === "function")
+      .map((lane) => [lane, runners[lane]]),
+  );
+  return {
+    enabled,
+    controlModel: "maestro-pi",
+    umbrella: "$maestro",
+    lanes: maestroGateLanes.map((id) => ({
+      id,
+      runner: laneRunners[id] ? "maestro" : "unavailable",
+      gated: id === "$build" || id === "$vet",
+    })),
+    surface: createPiMaestroToolSurface({ runners: laneRunners, ...options }),
+  };
+}
+
+export async function runPiMaestroExperimental({
+  agent,
+  tools,
+  beforeToolCall,
+  afterToolCall,
+} = {}) {
+  if (!agent || typeof agent.run !== "function") {
+    return {
+      handled: false,
+      reason: "Maestro Pi control runtime is not installed or was not provided",
+    };
+  }
+  const result = await agent.run({ tools, beforeToolCall, afterToolCall });
+  return { handled: true, result };
+}

package/src/runtime/preferences.js

@@ -0,0 +1,79 @@
+import { ensureDir, readJson, writeFileIfMissing, writeJson } from "../fs-utils.js";
+import { getRuntimeSubsystemPath } from "../paths.js";
+import { maskSensitiveText } from "./redaction-gateway.js";
+
+const scopes = ["user-local", "project-shared", "session-only"];
+const precedence = ["session-only", "project-shared", "user-local"];
+
+export function getPreferencesPath() {
+  return getRuntimeSubsystemPath("memory", "preferences.json");
+}
+
+export function createDefaultPreferences() {
+  return { schemaVersion: "0.1.0", preferences: {} };
+}
+
+export async function seedPreferences() {
+  await ensureDir(getRuntimeSubsystemPath("memory"));
+  await writeFileIfMissing(
+    getPreferencesPath(),
+    `${JSON.stringify(createDefaultPreferences(), null, 2)}\n`,
+  );
+}
+
+function sanitize(value) {
+  if (typeof value === "string") return maskSensitiveText(value).sanitizedText;
+  if (Array.isArray(value)) return value.map(sanitize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitize(item)]));
+  }
+  return value;
+}
+
+export async function loadPreferences() {
+  return readJson(getPreferencesPath()).catch(() => createDefaultPreferences());
+}
+
+export async function setPreference(key, value, { scope = "project-shared" } = {}) {
+  if (!key || !scopes.includes(scope)) throw new Error(`Unsupported preference scope: ${scope}`);
+  const current = await loadPreferences();
+  const next = {
+    ...current,
+    preferences: {
+      ...current.preferences,
+      [key]: { ...(current.preferences?.[key] ?? {}), [scope]: sanitize(value) },
+    },
+  };
+  await writeJson(getPreferencesPath(), next);
+  return next.preferences[key];
+}
+
+export async function clearPreference(key, { scope } = {}) {
+  const current = await loadPreferences();
+  if (!current.preferences?.[key]) return false;
+  const next = { ...current, preferences: { ...current.preferences } };
+  if (scope) {
+    if (!scopes.includes(scope)) throw new Error(`Unsupported preference scope: ${scope}`);
+    next.preferences[key] = { ...next.preferences[key] };
+    delete next.preferences[key][scope];
+    if (Object.keys(next.preferences[key]).length === 0) delete next.preferences[key];
+  } else delete next.preferences[key];
+  await writeJson(getPreferencesPath(), next);
+  return true;
+}
+
+export async function listPreferences() {
+  return (await loadPreferences()).preferences;
+}
+
+export async function resolvePreferences() {
+  const stored = await listPreferences();
+  return Object.fromEntries(
+    Object.entries(stored).map(([key, values]) => {
+      const scope = precedence.find((candidate) => values?.[candidate] !== undefined);
+      return [key, scope ? { value: values[scope], scope } : null];
+    }),
+  );
+}
+
+export { scopes as preferenceScopes };