agent-mockingbird 0.0.1

package/scripts/memory-trace-e2e.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${ROOT_DIR}"
+
+if ! command -v curl >/dev/null 2>&1; then
+  echo "[memory:trace:e2e] curl is required but not found in PATH."
+  exit 1
+fi
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "[memory:trace:e2e] bun is required but not found in PATH."
+  exit 1
+fi
+
+AGENT_MOCKINGBIRD_BASE_URL="${AGENT_MOCKINGBIRD_BASE_URL:-http://127.0.0.1:${AGENT_MOCKINGBIRD_PORT:-3001}}"
+MARKER="trace-e2e-$(date +%s)-$RANDOM"
+MEMORY_TEXT="Durable trace marker ${MARKER} should be recalled for E2E verification."
+SESSION_MODEL="${AGENT_MOCKINGBIRD_E2E_MODEL:-}"
+
+echo "[memory:trace:e2e] base URL: ${AGENT_MOCKINGBIRD_BASE_URL}"
+echo "[memory:trace:e2e] marker: ${MARKER}"
+
+echo "[memory:trace:e2e] health check"
+curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/health" >/dev/null
+
+echo "[memory:trace:e2e] writing durable memory seed"
+curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/memory/remember" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"fact\",\"source\":\"system\",\"content\":\"${MEMORY_TEXT}\"}" >/tmp/agent-mockingbird-memory-trace-remember.json
+
+if [[ -z "${SESSION_MODEL}" ]]; then
+  echo "[memory:trace:e2e] resolving model from existing sessions"
+  if SESSIONS_JSON="$(curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/sessions" 2>/dev/null)"; then
+    SESSION_MODEL="$(
+      printf '%s\n' "${SESSIONS_JSON}" \
+        | bun -e '
+          const payload = JSON.parse(await new Response(Bun.stdin.stream()).text());
+          const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+          const mainModel =
+            sessions.find((session) => session?.id === "main" && typeof session?.model === "string")?.model ?? "";
+          if (mainModel.trim()) {
+            console.log(mainModel.trim());
+            process.exit(0);
+          }
+          const firstModel =
+            sessions.find((session) => typeof session?.model === "string" && session.model.trim())?.model ?? "";
+          console.log(firstModel.trim());
+        '
+    )"
+  fi
+fi
+
+if [[ -z "${SESSION_MODEL}" ]]; then
+  echo "[memory:trace:e2e] resolving model from /api/opencode/models"
+  if MODELS_JSON="$(curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/opencode/models" 2>/dev/null)"; then
+    SESSION_MODEL="$(
+      printf '%s\n' "${MODELS_JSON}" \
+        | bun -e '
+          const payload = JSON.parse(await new Response(Bun.stdin.stream()).text());
+          const models = Array.isArray(payload.models) ? payload.models : [];
+          const firstId = models.find((model) => typeof model?.id === "string" && model.id.trim())?.id ?? "";
+          console.log(firstId);
+        '
+    )"
+  fi
+fi
+
+if [[ -z "${SESSION_MODEL}" ]]; then
+  echo "[memory:trace:e2e] no model available. Configure OpenCode models or set AGENT_MOCKINGBIRD_E2E_MODEL."
+  exit 1
+fi
+
+echo "[memory:trace:e2e] model: ${SESSION_MODEL}"
+SESSION_CREATE_PAYLOAD="$(
+  SESSION_MODEL="${SESSION_MODEL}" bun -e '
+    const model = (process.env.SESSION_MODEL ?? "").trim();
+    const payload = { title: "Memory Trace E2E", model };
+    console.log(JSON.stringify(payload));
+  '
+)"
+
+echo "[memory:trace:e2e] creating session"
+SESSION_ID="$(
+  curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/sessions" \
+    -H "Content-Type: application/json" \
+    -d "${SESSION_CREATE_PAYLOAD}" \
+    | bun -e 'const data=JSON.parse(await new Response(Bun.stdin.stream()).text()); console.log(data.session?.id ?? "");'
+)"
+
+if [[ -z "${SESSION_ID}" ]]; then
+  echo "[memory:trace:e2e] failed to create session."
+  exit 1
+fi
+
+echo "[memory:trace:e2e] session: ${SESSION_ID}"
+echo "[memory:trace:e2e] sending chat prompt through runtime"
+curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/chat" \
+  -H "Content-Type: application/json" \
+  -d "{\"sessionId\":\"${SESSION_ID}\",\"content\":\"Please answer briefly. Use any relevant memory for this marker: ${MARKER}\"}" \
+  >/tmp/agent-mockingbird-memory-trace-chat.json
+
+echo "[memory:trace:e2e] loading session messages"
+MESSAGES_JSON="$(curl -fsS "${AGENT_MOCKINGBIRD_BASE_URL}/api/sessions/${SESSION_ID}/messages")"
+printf '%s\n' "${MESSAGES_JSON}" >/tmp/agent-mockingbird-memory-trace-messages.json
+
+TRACE_SUMMARY="$(
+  printf '%s\n' "${MESSAGES_JSON}" \
+    | bun -e '
+      const payload = JSON.parse(await new Response(Bun.stdin.stream()).text());
+      const messages = Array.isArray(payload.messages) ? payload.messages : [];
+      const assistant = [...messages].reverse().find((message) => message.role === "assistant");
+      if (!assistant) {
+        console.log("NO_ASSISTANT");
+        process.exit(0);
+      }
+      const trace = assistant.memoryTrace;
+      if (!trace) {
+        console.log("NO_TRACE");
+        process.exit(0);
+      }
+      const injected = Number(trace.injectedContextResults ?? 0);
+      const toolCalls = Array.isArray(trace.toolCalls) ? trace.toolCalls.length : 0;
+      console.log(`TRACE injected=${injected} toolCalls=${toolCalls}`);
+      if (injected < 1) process.exit(2);
+    '
+)"
+
+if [[ "${TRACE_SUMMARY}" == "NO_ASSISTANT" ]]; then
+  echo "[memory:trace:e2e] no assistant message found."
+  exit 1
+fi
+
+if [[ "${TRACE_SUMMARY}" == "NO_TRACE" ]]; then
+  echo "[memory:trace:e2e] no memoryTrace found on assistant message."
+  exit 1
+fi
+
+echo "[memory:trace:e2e] ${TRACE_SUMMARY}"
+echo "[memory:trace:e2e] PASS"

package/scripts/migrate-opencode-env.ts

@@ -0,0 +1,108 @@
+import { applyConfigPatch, getConfigSnapshot } from "../apps/server/src/backend/config/service";
+
+const LEGACY_OPENCODE_ENV_KEYS = [
+  "AGENT_MOCKINGBIRD_OPENCODE_BASE_URL",
+  "AGENT_MOCKINGBIRD_OPENCODE_PROVIDER_ID",
+  "AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID",
+  "AGENT_MOCKINGBIRD_OPENCODE_MODEL_FALLBACKS",
+  "AGENT_MOCKINGBIRD_OPENCODE_SMALL_MODEL",
+  "AGENT_MOCKINGBIRD_OPENCODE_TIMEOUT_MS",
+  "AGENT_MOCKINGBIRD_OPENCODE_PROMPT_TIMEOUT_MS",
+  "AGENT_MOCKINGBIRD_OPENCODE_RUN_WAIT_TIMEOUT_MS",
+  "AGENT_MOCKINGBIRD_OPENCODE_DIRECTORY",
+] as const;
+
+function listLegacyOpencodeRuntimeEnvVars(source: Record<string, string | undefined> = process.env) {
+  return LEGACY_OPENCODE_ENV_KEYS.filter((key) => {
+    const value = source[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+
+function parseStringList(raw: string | undefined) {
+  if (!raw) return [];
+  const normalized = raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+  return [...new Set(normalized)];
+}
+
+function parsePositiveInt(raw: string | undefined) {
+  if (!raw) return null;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+
+function trimOrNull(raw: string | undefined) {
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+async function main() {
+  const present = listLegacyOpencodeRuntimeEnvVars();
+  if (present.length === 0) {
+    console.log("[config:migrate-opencode-env] No deprecated AGENT_MOCKINGBIRD_OPENCODE_* runtime vars found.");
+    return;
+  }
+
+  const patch: Record<string, unknown> = {};
+
+  const baseUrl = trimOrNull(process.env.AGENT_MOCKINGBIRD_OPENCODE_BASE_URL);
+  if (baseUrl) patch.baseUrl = baseUrl;
+  const providerId = trimOrNull(process.env.AGENT_MOCKINGBIRD_OPENCODE_PROVIDER_ID);
+  if (providerId) patch.providerId = providerId;
+  const modelId = trimOrNull(process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID);
+  if (modelId) patch.modelId = modelId;
+  const fallbackModels = parseStringList(process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_FALLBACKS);
+  if (fallbackModels.length > 0) patch.fallbackModels = fallbackModels;
+  const smallModel = trimOrNull(process.env.AGENT_MOCKINGBIRD_OPENCODE_SMALL_MODEL);
+  if (smallModel) patch.smallModel = smallModel;
+  const timeoutMs = parsePositiveInt(process.env.AGENT_MOCKINGBIRD_OPENCODE_TIMEOUT_MS);
+  if (timeoutMs) patch.timeoutMs = timeoutMs;
+  const promptTimeoutMs = parsePositiveInt(process.env.AGENT_MOCKINGBIRD_OPENCODE_PROMPT_TIMEOUT_MS);
+  if (promptTimeoutMs) patch.promptTimeoutMs = promptTimeoutMs;
+  const runWaitTimeoutMs = parsePositiveInt(process.env.AGENT_MOCKINGBIRD_OPENCODE_RUN_WAIT_TIMEOUT_MS);
+  if (runWaitTimeoutMs) patch.runWaitTimeoutMs = runWaitTimeoutMs;
+  const directory = trimOrNull(process.env.AGENT_MOCKINGBIRD_OPENCODE_DIRECTORY);
+  if (directory) patch.directory = directory;
+
+  if (Object.keys(patch).length === 0) {
+    console.log("[config:migrate-opencode-env] Deprecated vars are present but no valid values were parsed.");
+    return;
+  }
+
+  const snapshot = getConfigSnapshot();
+  const result = await applyConfigPatch({
+    expectedHash: snapshot.hash,
+    runSmokeTest: false,
+    patch: {
+      runtime: {
+        opencode: patch,
+      },
+    },
+  });
+
+  console.log("[config:migrate-opencode-env] Migrated values into agent-mockingbird config.");
+  console.log(
+    JSON.stringify(
+      {
+        configPath: result.snapshot.path,
+        previousHash: snapshot.hash,
+        nextHash: result.snapshot.hash,
+        appliedFields: Object.keys(patch).sort(),
+        migratedEnvVars: present,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log("[config:migrate-opencode-env] Remove deprecated AGENT_MOCKINGBIRD_OPENCODE_* runtime vars before starting agent-mockingbird.");
+}
+
+void main().catch((error) => {
+  console.error("[config:migrate-opencode-env] Failed:", error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});

package/scripts/onboard/bootstrap.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REGISTRY_URL="${AGENT_MOCKINGBIRD_REGISTRY_URL:-https://registry.npmjs.org/}"
+AGENT_MOCKINGBIRD_TAG="${AGENT_MOCKINGBIRD_TAG:-latest}"
+PUBLIC_NPM_REGISTRY_URL="${AGENT_MOCKINGBIRD_PUBLIC_REGISTRY_URL:-https://registry.npmjs.org/}"
+
+if ! command -v npm >/dev/null 2>&1; then
+  echo "npm is required. Please install npm and run again."
+  exit 1
+fi
+
+if [[ $# -eq 0 ]]; then
+  set -- install
+fi
+
+tmp_npmrc="$(mktemp)"
+cleanup() {
+  rm -f "${tmp_npmrc}"
+}
+trap cleanup EXIT
+
+{
+  printf "registry=%s\n" "${REGISTRY_URL}"
+} > "${tmp_npmrc}"
+
+exec npm exec \
+  --yes \
+  --userconfig "${tmp_npmrc}" \
+  --package "@waffleophagus/agent-mockingbird-installer@${AGENT_MOCKINGBIRD_TAG}" \
+  agent-mockingbird-installer \
+  -- "$@"

package/scripts/opencode-swap.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+
+const repoRoot = path.resolve(import.meta.dir, "..");
+
+type ParsedArgs = {
+  ref?: string;
+  yes: boolean;
+};
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const parsed: ParsedArgs = { yes: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--yes" || arg === "-y") {
+      parsed.yes = true;
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new Error("Missing value after --ref.");
+      }
+      parsed.ref = value;
+      index += 1;
+      continue;
+    }
+    if (!parsed.ref) {
+      parsed.ref = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return parsed;
+}
+
+async function promptForRef(current?: string) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = (await rl.question(`OpenCode version/tag to hard swap to${current ? ` [${current}]` : ""}: `)).trim();
+    return answer || current || "";
+  } finally {
+    rl.close();
+  }
+}
+
+function run(ref: string) {
+  const result = spawnSync("bun", ["run", "./scripts/opencode-sync.ts", "--hard-ref", ref], {
+    cwd: repoRoot,
+    stdio: "inherit",
+    env: process.env,
+  });
+  process.exit(result.status ?? 1);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const ref = args.ref || (await promptForRef());
+  if (!ref) {
+    throw new Error("No version/tag provided.");
+  }
+
+  if (!args.yes) {
+    console.log(`Hard-swapping OpenCode to ${ref}. This discards current vendor/opencode state before rebuilding.`);
+  }
+  run(ref);
+}
+
+await main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});