agent-mockingbird 0.0.1

package/.opencode/tools/config_manager.ts

@@ -0,0 +1,87 @@
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+function resolveApiBaseUrl() {
+  const explicit = process.env.AGENT_MOCKINGBIRD_CONFIG_API_BASE_URL?.trim();
+  if (explicit) return explicit.replace(/\/+$/, "");
+  const memoryAlias = process.env.AGENT_MOCKINGBIRD_MEMORY_API_BASE_URL?.trim();
+  if (memoryAlias) return memoryAlias.replace(/\/+$/, "");
+  const cronAlias = process.env.AGENT_MOCKINGBIRD_CRON_API_BASE_URL?.trim();
+  if (cronAlias) return cronAlias.replace(/\/+$/, "");
+  const port = process.env.AGENT_MOCKINGBIRD_PORT?.trim() || process.env.PORT?.trim() || "3001";
+  return `http://127.0.0.1:${port}`;
+}
+
+async function requestJson(pathname: string, init?: RequestInit) {
+  const response = await fetch(`${resolveApiBaseUrl()}${pathname}`, init);
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+    throw new Error(error);
+  }
+  return payload;
+}
+
+const argsSchema = z.discriminatedUnion("action", [
+  z.object({ action: z.literal("get_config") }),
+  z.object({
+    action: z.literal("patch_config"),
+    patch: z.unknown(),
+    expectedHash: z.string().min(1),
+    runSmokeTest: z.boolean().optional(),
+  }),
+  z.object({
+    action: z.literal("replace_config"),
+    config: z.unknown(),
+    expectedHash: z.string().min(1),
+    runSmokeTest: z.boolean().optional(),
+  }),
+]);
+
+export default tool({
+  description:
+    "Read or update Agent Mockingbird managed config through validated APIs with hash conflict detection and optional smoke tests.",
+  args: {
+    action: tool.schema.enum(["get_config", "patch_config", "replace_config"]),
+    patch: tool.schema.unknown().optional(),
+    config: tool.schema.unknown().optional(),
+    expectedHash: tool.schema.string().min(1).optional(),
+    runSmokeTest: tool.schema.boolean().optional(),
+  },
+  async execute(rawArgs: {
+    action: "get_config" | "patch_config" | "replace_config";
+    patch?: unknown;
+    config?: unknown;
+    expectedHash?: string;
+    runSmokeTest?: boolean;
+  }) {
+    const args = argsSchema.parse(rawArgs);
+
+    if (args.action === "get_config") {
+      const payload = await requestJson("/api/waffle/runtime/config");
+      return JSON.stringify({ ok: true, ...payload });
+    }
+
+    if (args.action === "patch_config") {
+      const payload = await requestJson("/api/waffle/runtime/config", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          patch: args.patch,
+          expectedHash: args.expectedHash,
+        }),
+      });
+      return JSON.stringify({ ok: true, ...payload });
+    }
+
+    const payload = await requestJson("/api/waffle/runtime/config/replace", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        config: args.config,
+        expectedHash: args.expectedHash,
+      }),
+    });
+    return JSON.stringify({ ok: true, ...payload });
+  },
+});

package/.opencode/tools/cron_manager.ts

@@ -0,0 +1,145 @@
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+function resolveApiBaseUrl() {
+  const explicit = process.env.AGENT_MOCKINGBIRD_CRON_API_BASE_URL?.trim();
+  if (explicit) return explicit.replace(/\/+$/, "");
+  const memoryAlias = process.env.AGENT_MOCKINGBIRD_MEMORY_API_BASE_URL?.trim();
+  if (memoryAlias) return memoryAlias.replace(/\/+$/, "");
+  const port = process.env.AGENT_MOCKINGBIRD_PORT?.trim() || process.env.PORT?.trim() || "3001";
+  return `http://127.0.0.1:${port}`;
+}
+
+async function postJson(pathname: string, body: unknown) {
+  const response = await fetch(`${resolveApiBaseUrl()}${pathname}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+    throw new Error(error);
+  }
+  return payload;
+}
+
+const scheduleKindSchema = z.enum(["at", "every", "cron"]);
+const runModeSchema = z.enum(["background", "conditional_agent", "agent"]);
+const payloadSchema = z.record(z.string(), z.unknown());
+
+const jobCreateSchema = z.object({
+  id: z.string().min(1).optional(),
+  name: z.string().min(1),
+  enabled: z.boolean().optional(),
+  scheduleKind: scheduleKindSchema,
+  scheduleExpr: z.string().min(1).nullable().optional(),
+  everyMs: z.number().int().positive().nullable().optional(),
+  atIso: z.string().min(1).nullable().optional(),
+  timezone: z.string().min(1).nullable().optional(),
+  runMode: runModeSchema,
+  handlerKey: z.string().min(1).nullable().optional(),
+  conditionModulePath: z.string().min(1).nullable().optional(),
+  conditionDescription: z.string().min(1).nullable().optional(),
+  agentPromptTemplate: z.string().min(1).nullable().optional(),
+  agentModelOverride: z.string().min(1).nullable().optional(),
+  maxAttempts: z.number().int().positive().optional(),
+  retryBackoffMs: z.number().int().positive().optional(),
+  payload: payloadSchema.optional(),
+});
+
+const jobPatchSchema = z.object({
+  name: z.string().min(1).optional(),
+  enabled: z.boolean().optional(),
+  scheduleKind: scheduleKindSchema.optional(),
+  scheduleExpr: z.string().min(1).nullable().optional(),
+  everyMs: z.number().int().positive().nullable().optional(),
+  atIso: z.string().min(1).nullable().optional(),
+  timezone: z.string().min(1).nullable().optional(),
+  runMode: runModeSchema.optional(),
+  handlerKey: z.string().min(1).nullable().optional(),
+  conditionModulePath: z.string().min(1).nullable().optional(),
+  conditionDescription: z.string().min(1).nullable().optional(),
+  agentPromptTemplate: z.string().min(1).nullable().optional(),
+  agentModelOverride: z.string().min(1).nullable().optional(),
+  maxAttempts: z.number().int().positive().optional(),
+  retryBackoffMs: z.number().int().positive().optional(),
+  payload: payloadSchema.optional(),
+});
+
+const argsSchema = z.discriminatedUnion("action", [
+  z.object({ action: z.literal("list_jobs") }),
+  z.object({ action: z.literal("list_handlers") }),
+  z.object({ action: z.literal("health") }),
+  z.object({ action: z.literal("get_job"), jobId: z.string().min(1) }),
+  z.object({ action: z.literal("create_job"), job: jobCreateSchema }),
+  z.object({ action: z.literal("upsert_job"), job: jobCreateSchema }),
+  z.object({ action: z.literal("update_job"), jobId: z.string().min(1), patch: jobPatchSchema }),
+  z.object({ action: z.literal("enable_job"), jobId: z.string().min(1) }),
+  z.object({ action: z.literal("disable_job"), jobId: z.string().min(1) }),
+  z.object({ action: z.literal("describe_contract") }),
+  z.object({ action: z.literal("delete_job"), jobId: z.string().min(1) }),
+  z.object({ action: z.literal("run_job_now"), jobId: z.string().min(1) }),
+  z.object({
+    action: z.literal("list_instances"),
+    jobId: z.string().min(1).optional(),
+    limit: z.number().int().positive().optional(),
+  }),
+  z.object({ action: z.literal("list_steps"), instanceId: z.string().min(1) }),
+]);
+
+export default tool({
+  description: "Manage Agent Mockingbird cron jobs (list/create/update/run/delete/inspect).",
+  args: {
+    action: tool.schema.enum([
+      "list_jobs",
+      "list_handlers",
+      "health",
+      "get_job",
+      "create_job",
+      "upsert_job",
+      "update_job",
+      "enable_job",
+      "disable_job",
+      "describe_contract",
+      "delete_job",
+      "run_job_now",
+      "list_instances",
+      "list_steps",
+    ]),
+    jobId: tool.schema.string().optional(),
+    instanceId: tool.schema.string().optional(),
+    limit: tool.schema.number().int().positive().optional(),
+    job: tool.schema.unknown().optional(),
+    patch: tool.schema.unknown().optional(),
+  },
+  async execute(rawArgs: {
+    action:
+      | "list_jobs"
+      | "list_handlers"
+      | "health"
+      | "get_job"
+      | "create_job"
+      | "upsert_job"
+      | "update_job"
+      | "enable_job"
+      | "disable_job"
+      | "describe_contract"
+      | "delete_job"
+      | "run_job_now"
+      | "list_instances"
+      | "list_steps";
+    jobId?: string;
+    instanceId?: string;
+    limit?: number;
+    job?: unknown;
+    patch?: unknown;
+  }) {
+    const args = argsSchema.parse(rawArgs);
+    const payload = await postJson("/api/waffle/cron/manage", args);
+    return JSON.stringify({
+      ok: true,
+      ...payload,
+    });
+  },
+});

package/.opencode/tools/memory_get.ts

@@ -0,0 +1,43 @@
+import { tool } from "@opencode-ai/plugin";
+
+function resolveApiBaseUrl() {
+  const explicit = process.env.AGENT_MOCKINGBIRD_MEMORY_API_BASE_URL?.trim();
+  if (explicit) return explicit.replace(/\/+$/, "");
+  const port = process.env.AGENT_MOCKINGBIRD_PORT?.trim() || process.env.PORT?.trim() || "3001";
+  return `http://127.0.0.1:${port}`;
+}
+
+async function postJson(pathname: string, body: unknown) {
+  const response = await fetch(`${resolveApiBaseUrl()}${pathname}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+    throw new Error(error);
+  }
+  return payload;
+}
+
+export default tool({
+  description: "Read a safe slice of canonical markdown memory files by path and line window.",
+  args: {
+    path: tool.schema.string().min(1).describe("Memory path such as MEMORY.md or memory/2026-02-17.md"),
+    from: tool.schema.number().int().min(1).optional().describe("Start line number (1-based)"),
+    lines: tool.schema.number().int().min(1).max(400).optional().describe("Number of lines to return"),
+  },
+  async execute(args: { path: string; from?: number; lines?: number }) {
+    const payload = await postJson("/api/waffle/memory/read", {
+      path: args.path,
+      from: args.from,
+      lines: args.lines,
+    });
+    return JSON.stringify({
+      ok: true,
+      path: payload.path,
+      text: payload.text,
+    });
+  },
+});

package/.opencode/tools/memory_remember.ts

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin";
+
+function resolveApiBaseUrl() {
+  const explicit = process.env.AGENT_MOCKINGBIRD_MEMORY_API_BASE_URL?.trim();
+  if (explicit) return explicit.replace(/\/+$/, "");
+  const port = process.env.AGENT_MOCKINGBIRD_PORT?.trim() || process.env.PORT?.trim() || "3001";
+  return `http://127.0.0.1:${port}`;
+}
+
+async function postJson(pathname: string, body: unknown) {
+  const response = await fetch(`${resolveApiBaseUrl()}${pathname}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (!response.ok && response.status !== 422) {
+    const error = typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+    throw new Error(error);
+  }
+  return { ok: response.ok, status: response.status, payload };
+}
+
+export default tool({
+  description: "Persist a memory note so it can be retrieved later.",
+  args: {
+    content: tool.schema.string().min(1),
+    confidence: tool.schema.number().min(0).max(1).optional(),
+    source: tool.schema.enum(["assistant", "user", "system"]).optional(),
+    entities: tool.schema.array(tool.schema.string()).optional(),
+    supersedes: tool.schema.array(tool.schema.string()).optional(),
+    topic: tool.schema.string().optional(),
+  },
+  async execute(args: {
+    content: string;
+    confidence?: number;
+    source?: "assistant" | "user" | "system";
+    entities?: string[];
+    supersedes?: string[];
+    topic?: string;
+  }) {
+    const response = await postJson("/api/waffle/memory/remember", {
+      ...args,
+      source: args.source ?? "assistant",
+    });
+
+    return JSON.stringify({
+      ok: response.ok,
+      status: response.status,
+      result: response.payload,
+    });
+  },
+});

package/.opencode/tools/memory_search.ts

@@ -0,0 +1,48 @@
+import { tool } from "@opencode-ai/plugin";
+
+function resolveApiBaseUrl() {
+  const explicit = process.env.AGENT_MOCKINGBIRD_MEMORY_API_BASE_URL?.trim();
+  if (explicit) return explicit.replace(/\/+$/, "");
+  const port = process.env.AGENT_MOCKINGBIRD_PORT?.trim() || process.env.PORT?.trim() || "3001";
+  return `http://127.0.0.1:${port}`;
+}
+
+async function postJson(pathname: string, body: unknown) {
+  const response = await fetch(`${resolveApiBaseUrl()}${pathname}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+    throw new Error(error);
+  }
+  return payload;
+}
+
+export default tool({
+  description: "Search memory for relevant prior context.",
+  args: {
+    query: tool.schema.string().min(1).describe("Natural language memory query"),
+    maxResults: tool.schema.number().int().min(1).max(20).optional(),
+    minScore: tool.schema.number().min(0).max(1).optional(),
+    debug: tool.schema.boolean().optional().describe("Include retrieval debug details."),
+  },
+  async execute(args: { query: string; maxResults?: number; minScore?: number; debug?: boolean }) {
+    const payload = await postJson("/api/waffle/memory/retrieve", {
+      query: args.query,
+      maxResults: args.maxResults,
+      minScore: args.minScore,
+      debug: args.debug,
+    });
+    const results = Array.isArray(payload.results) ? payload.results : [];
+    return JSON.stringify({
+      ok: true,
+      query: args.query,
+      count: results.length,
+      results,
+      debug: args.debug ? payload.debug : undefined,
+    });
+  },
+});

package/AGENTS.md

@@ -0,0 +1,126 @@
+THIS IS A NON-PRODUCTION APP Do not assume we need to make migrations or support old systems if we're doing large scale refactors. Assume we can make breaking changes as long as this is here, as there are no users other than me, the author, testing it. And all my tests get wiped when done. If we are making a newer better system, no need to support the old one at all.
+
+
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Use `bunx <package> <command>` instead of `npx <package> <command>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
+- Bun.$`ls` instead of execa.
+
+## Testing
+
+Use `bun test` to run tests.
+
+```ts#index.test.ts
+import { test, expect } from "bun:test";
+
+test("hello world", () => {
+  expect(1).toBe(1);
+});
+```
+
+## Frontend
+
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+
+Server:
+
+```ts#index.ts
+import index from "./index.html"
+
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+
+With the following `frontend.tsx`:
+
+```tsx#frontend.tsx
+import React from "react";
+import { createRoot } from "react-dom/client";
+
+// import .css files directly and it works
+import './index.css';
+
+const root = createRoot(document.body);
+
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+
+root.render(<Frontend />);
+```
+
+Then, run index.ts
+
+```sh
+bun --hot ./index.ts
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.
+
+## Temporary Streamdown Integration Rule
+
+For the mobile Streamdown integration effort:
+- Treat `/var/home/matt/Documents/random-vibecoded-stuff/streamdown` as the source of truth for Streamdown library changes.
+- Do not patch Streamdown library internals in this repo when the same change can be made in the Streamdown fork.
+- Keep changes in this repo limited to integration wiring (dependencies, config, app usage), while implementing library fixes/features in the Streamdown fork for upstream publishing.
+- If a Streamdown-side change is required, make it in the fork first, then consume it here via local dependency links.
+
+## OpenCode Workflow
+
+- Do not edit `cleanroom/opencode` directly.
+- If a task needs shipped OpenCode source changes, run `bun run opencode:sync --rebuild-only` first.
+- Make OpenCode edits only in `vendor/opencode`.
+- Commit OpenCode changes in the `vendor/opencode` worktree before exporting them.
+- Run `bun run opencode:sync --export-patches` after committing OpenCode changes.
+- Use `bun run opencode:sync --ref <tag>` for upstream bumps.
+- If `vendor/opencode` is dirty, do not run `--ref` or `--export-patches`.

package/MEMORY.md

@@ -0,0 +1,2 @@
+# Memory
+