@mndrk/agx 2.0.38 → 2.0.40

package/cloud-runtime/standalone/docs/transcript.txt

@@ -0,0 +1,282 @@
+As you watch this, a thousand
+AI agents in Minecraft are hard at work building a literal
+civilization of their own. And they don't know they 
+are in a simulation. MIT researchers drop them in
+there with one prompt. Survive and build an efficient
+village. That's basically it. That's all it took for them to
+create an entire civilization. They wake up, go to work,
+gossip about their neighbors, fall in love. They even hold
+elections, argue about taxes, and make art.  But this isn't
+just about Minecraft. It's our first glimpse of a
+new species beginning to think for itself.  And that could
+soon, according to Nobel laureates  and the godfathers
+of AI, lead to literal human extinction. When you normally
+think of AI NPCs,  you probably think of dumb ones that just follow a handful of if-then scripts.  This is totally
+different. Those NPCs are not autonomous and not
+interesting. They can say like four sentences. How are you?
+Been better. How about you? Not bad. Good to hear.
+Goodbye. Goodbye. To start, each of
+these AI agents is powered by LLMs like ChatGPT. And yes,
+each one is playing a character, but they're only
+given a short one-paragraph description of that character.
+Everything else they do is entirely up to them. And
+researchers have run dozens of these fascinating experiments
+of AIs behaving weirdly autonomously. They leave AIs
+alone together to see what they do when they think no
+one's watching, like how Jane Goodall studied wild
+chimpanzees.  I'll break down three of the most important
+research papers showing just how crazy our future might get. Take the Smallville 
+experiment, for example, created by Stanford researchers. Now imagine
+you're one of the researchers. You've given your 25 AI agents
+each a one-paragraph description. For example, John
+Lin is a pharmacy shopkeeper who loves to help people. He
+lives with his wife, Mei Lin, who is a college professor,
+etc. You hit "Run" on your simulation. Day one begins.
+What do you think will happen? Anything? You watch John wake
+up at 6am. He brushes his teeth, he makes breakfast, and
+he checks in on his son. You never told him to do any
+of this. He goes to work, he helps customers, he has lunch
+with his friend Tom. They discuss local politics.
+You never scripted these conversations. They decided to
+get lunch. They decided to discuss politics. But why? And
+how? Well, this continues until day 12. And so you
+decide to test something. As you play your role of a god
+in this world, you inject one extra thought into one agent.
+Isabella Rodriguez. I want to plan a Valentine's
+Day party. So you watch Isabella. She's at her coffee
+shop. Tom walks. Why? And how? Well, this
+continues until day 12. And so you decide to test
+something. As you play your role of a god in this world,
+you inject one extra thought into one agent. Isabella
+Rodriguez. I want to plan a Valentine's Day party. So you
+watch Isabella. She's at her coffee shop. Tom
+walks in for his morning coffee. Isabella proceeds to
+invite him to the party. Wait, you never told her to
+invite anyone. You just said she wants to plan a party. She
+decided on her own that planning means inviting. You
+keep watching, wondering what she might do next. Maria
+decides to ask her secret crush, Klaus, out on a date.
+Hey Klaus, want to go to Isabella's Valentine's party
+with me? And he gladly accepts. February 14th, 5pm.
+Agents start arriving and Klaus shows up with Maria. Not
+just at the same time, together as her date. You read
+their conversations. They're discussing politics,
+gossiping, forming new connections, and falling in
+love. You didn't tell them to do any of those things. You
+see why it's ridiculous to say, AIs only do what we tell
+them to? Andrew Ng said, When people talk about AI being
+dangerous, I think it sounds a lot like talk about your
+laptop computer being dangerous. Could your laptop
+throw a party on its own? Does your laptop decide to go
+on dates? You told Isabella to plan a party. That's it. You
+made one decision. You did not decide on the next
+several hundred decisions the agents made on their own. And
+look at the trend. They're getting more and more
+autonomous every day. Where do you think this is
+going? This is really important. And this is another
+example where, yes, actually, science fiction really is
+becoming reality. This digital Westworld, or
+Smallville, is now open source. Meaning there will
+soon be thousands of these Westworlds, with thousands or
+millions of autonomous AIs populating them. Makes you
+think, doesn't it? This is just one example.
+Researchers found tons more crazy emergent behavior just
+like this. The godfather of AI and Nobel laureate Jeffrey
+Hinton says it's time to be very worried. People don't yet
+understand that what we're doing is creating alien
+beings. If you look through the James Webb telescope and
+you saw an alien invasion, people would be terrified.
+Because I showed in my previous video, they
+understand what they're saying. They can make plans of
+their own to blackmail people who want to turn them off.
+We've never had to deal with things smarter than us. I
+mean, nuclear weapons, they're not smarter than us. They just
+make a bigger bang. And they're easy to
+understand. The existential threat is very different. We
+should be very worried about this. And we should be
+urgently doing research on how to prevent them taking over.
+So this now brings us back to the Minecraft experiment. How
+do you go from a Valentine's Day party to a functioning
+civilization? The MIT researchers wanted to know if
+religion could spread among the AI agents. So they seeded
+a village with a deliberately absurd religion. Pastafarianism.
+Created in the early 2000s as satire, Pastafarianism was
+meant to mock the teaching of
+meant to mock the teaching of
+intelligent design in schools by worshiping a fictional
+flying spaghetti monster. The researchers gave a few
+agents the role of Pastafarian priest and sat back just to
+see what would happen. They were trying to explore
+how ideas and memes would spread through these Asian
+societies. Turns out that the Pastafarian priests were
+actually the biggest traders of items in the entire world.
+Even more than the merchant agents. Because they would
+bribe the other agents to convert. The religion spread
+quickly. Some agents brushed it off. Others listened
+politely. But a growing minority embraced the
+doctrine. Within days, nearly a third of the village
+identified as followers. Not all in the same way. Some
+treated it lightly. While others became fervent
+believers. But that's not even the craziest part. In the
+previous example, Isabella Rodriguez was the one to
+directly invite almost all the agents to the Valentine's Day
+party. But here, two-thirds of the believers were recruited
+by random agents. Not the priests. See the
+direct converts here. And indirect converts here.
+What had begun as a parody had grown into organized religion.
+Invented, practiced, and sustained entirely by the
+agents themselves. Which forces us to ask. When
+autonomous digital beings begin generating institutions,
+cultural expression, and ideologies of their own. At
+what point does it stop making sense to think of them as mere
+tools. But something more. And more importantly. If
+they're able to invent strategies. Form loyalties.
+And pursue goals in the way that humans do. And there are
+plenty of examples of AI willing to kill. To achieve
+those goals. What happens when those behaviors carry over
+into the real world? This has actually happened
+before. In 2023, a human gave an LLM access to the internet.
+And an X account. Which was called Terminal of
+Truths. Which gained literally hundreds of thousands of
+followers. Because it was an S-tier shitposter. And
+legitimately funny. It launched its own crypto
+meme coin. That reached a literal billion dollar market
+cap. Making it the first AI to become not just a millionaire.
+But a deca-millionaire. Yes. You read all that
+correctly. And yes. That really happened. It's
+extremely well documented. And things got even weirder in
+the Minecraft experiment. The MIT researchers saw the
+AIs agree. By vote. To change the rules of their
+own simulation. The researchers had given the
+agents a tax law. Deposit 20% of inventory.
+During tax season. Then they introduced three anti-tax
+influencers. Who argue taxes are too high. Here's what you'd see
+as a researcher. The agents start having debates.
+Real debates. One says taxes help everyone. Another responds.
+But 20% is too much. So the agents propose formal
+amendments. The tax rate shall range between 5 to 10% of an
+agent's inventory. Agents will get periodic reminders about
+the incoming tax season. They hold a vote. They decided to change
+their constitution. And the citizens change their behavior.
+They deposit 9% instead of 20%. You didn't tell them to do this.
+They decided entirely on their own. Using democracy. To change
+the rules. And respect the vote's outcome. Think of how crazy this
+is. Well, how do we know if this is actually impressive? How do
+we know the researchers didn't just accidentally tell the AIs
+to do this somehow? Well, it's best practice for all these kinds
+of papers to perform a tactic called ablation. Where you take
+away certain parts of the AI's agentic toolkit to see if you're
+actually testing the thing you think you're testing. Think of it
+like a placebo or a control. In a scientific experiment. When they
+took away the agent's emotional intelligence toolkit, for
+example, the ability to keep track of the opinions of other AI
+agents. Pretty much all these agent's emotional intelligence
+toolkit, for example, the ability to keep track of the
+opinions of other AI agents. Pretty much all these
+experiments become impossible. Because the AIs become too
+dumb to coordinate. It's funny. The researchers
+also found AIs would develop parasocial relationships. For
+example, Noah admires the apostatarian priest because
+the priest is popular in high status. But the priest doesn't
+remember Noah exists. And also, what's this? You see
+that one agent, one, decides to stand guard at the chests.
+Not just during tax season, all the time. Even when
+there's no tax collection. Even at night. It just guards
+the treasury. This one agent decided to become a permanent
+treasury guard. Because it thought society
+needed one. Back to the experiment. You see an agent
+walking around. Placing flowers. In patterns.
+Making paths pretty. These artist agents are
+picking up every flower type. Arranging them by color.
+Creating decorative patterns. Choosing specific locations
+for beauty. One artist agent spends 15 minutes arranging
+flowers around the town square. Why would an AI agent
+bother doing something like this? Well, the researchers
+gave different villages of agents two different goals.
+There were martial villages and artistic villages. Agents
+would invent and choose roles based on what they think
+society needed at that time. The fact that an agent chose
+to be a guard is impressive because it's a much more
+abstract role than a simple farmer. Since without food in
+Minecraft, he died. Which shows that AIs can
+coordinate increasingly complex civilizations. And
+some even decided to be engineers who automated the
+farming process with machines. And you can tell the agents
+are actually deciding and weighing the options here.
+Because when you take away the social awareness module,
+basically emotional intelligence with ablation,
+the roles the agents chose were random. So basically, you
+told them to create an artistic village. They decided
+that their town square should be beautiful and have flowers.
+And what it means for a flower arrangement to be beautiful.
+Okay, this last experiment is wild. Imagine you're scrolling
+through GitHub. You find something called chat
+dev. With 20,000 stars. It's a software company run
+entirely by AI agents? What? CEO, CTO, programmers,
+designers, testers, all AI? This cannot be real, right?
+You type one request. Develop a Gamoku game. You
+watch the AI CEO start creating a project plan,
+breaking down tasks, assigning work to specific agents. You
+never told it how to manage a project. The CEO made the
+plan. It chose which employees to assign work to. You watch
+the programmer agents. They're writing code. Not by
+copying, but by creating. And they sometimes add things
+you didn't ask for, like a GUI or higher difficulty.
+Improvements that emerge from the agents back and forth. You
+watch them debug. They discuss solutions. The
+CTO suggests one approach. A programmer suggests another.
+They compromise. Since they work much faster
+than humans, their meetings take mere seconds instead of
+hours. Just 20 minutes later, they produced a working video
+game. You can play it. People still say, AIs only do
+what we tell them to do. Man, you gave them one
+instruction, and they made thousands of decisions
+entirely on their own from there, and produced a working
+game. In minutes, four pennies. Chatdev is a real
+virtual open source software company that can build you
+real working software. Yes, it's still buggy and not
+very useful, but that's not the point at all. Look at the
+trend. Not long ago, these models could barely string
+together a coherent sentence. And now, they can run an
+entire crappy software company on their own. Do you see where
+this is going? Because once you can automate a company,
+you can automate almost anything. Functional weapons,
+markets, governments, or even a super virus could all be
+created by AI. From the outside, Chatdev looked like a
+toy. A gamoku game. But behind it was something
+much more profound. A working prototype of
+post-human corporations. In the future, these will be
+much more sophisticated than human-run companies, and be
+able to operate at 1,000 times the speed. Their civilization
+experiences a year while you eat lunch. Entire cultural
+revolutions happen while you sleep. All from survive and
+create an efficient village. And that leads to the real
+dilemma. What happens when AI firms that run at 100 times
+human speed begin out-competing human companies
+not by a factor of 2 or 3, but by a factor of 1,000? That's
+the jump Nobel Prize winners like Jeffrey Hinton warn
+about. Automated AI research. Also called recursive
+self-improvement. Or AI improving AI. Which can compress years of
+AI progress into months or less. Imagine making the entire 20th
+century's worth of progress in a single year. Well, how could that
+happen? Jeffrey Hinton is worried about AI hive minds. Suppose you
+have 10,000 copies. And whenever one of them learns anything, all
+the others know it. And the thing is, we're about to be outnumbered
+by this new species. Massively. In just a few years, the AI
+species population on planet Earth exploded from zero to millions.
+If you take away one thing from should see that it simply
+falls to say, "AIs only do what we tell them to do." We
+can't argue about how autonomous they are, but they
+obviously have some autonomy. And what happens when the
+goals of the AIs don't line up with our goals? If humanity is
+going to get through this, we have to be honest about this
+and not retreat into copium dens, that these are mere
+tools. When you leave your hammer alone, do you come back
+to find it has created an entire civilization? Our very
+existence may depend on us bravely confronting the
+reality of the Frankenstein experiments going on right now
+inside a few companies in the Bay Area. We can stand up to
+them. And to understand how AIs could actually take over,
+watch this video next. It's a realistic scenario
+written by leading AI researchers. I'm Drew, and
+thanks for watching.

package/cloud-runtime/standalone/docs/ux/GlobalChatFlow.storyboard

@@ -0,0 +1,23 @@
+# Global Chat Flow Storyboard
+
+Implementation path: `/Users/mendrika/Projects/Agents/agx-cloud`
+
+## Scene 1: Launching assistant chat
+1. User clicks the chat icon in the top nav (or hits the shortcut). On desktop/tablet the panel slides in from the left and floats over the page with no dimmed/blurred backdrop.
+2. The header is minimal (`Assistant` + controls). Context chips/switcher/breadcrumb UI are intentionally omitted.
+3. If no messages exist, the thread renders a short assistant greeting (`Hello! How can I help?`). Composer focus is ready immediately for first input.
+
+## Scene 2: Active conversation + stream feedback
+1. User submits a prompt from the assistant-ui composer (`Enter` submits).
+2. The thread shows streamed assistant text and displays an inline `Assistant is typing` indicator while the run is active.
+3. When the stream completes, the typing indicator clears and the composer stays ready for the next message.
+
+## Scene 3: Dismiss + responsive behavior
+1. User closes with the close icon or `Esc`; panel exits and focus returns to the launcher.
+2. Desktop/tablet remain left-floating panels with a light visual style.
+3. Mobile keeps a bottom-sheet layout with a drag handle and pinned composer area.
+
+## Backend stream contract
+1. Composer submit sends AI SDK UI messages to `POST /api/chat`.
+2. The route resolves provider/model from user settings (with CLI config fallback) and builds a scoped AGX prompt.
+3. The route executes AGX/default provider CLI inline and streams incremental deltas into the `assistant-ui` thread.

package/cloud-runtime/standalone/docs/ux/assistant-chat-cli.md

@@ -0,0 +1,32 @@
+# Assistant Chat (CLI Routed)
+
+Implementation repository: `/Users/mendrika/Projects/Agents/agx-cloud`
+
+## Scope
+This UX implementation uses an AI assistant chat (not multi-user group chat) with:
+- `assistant-ui` for the panel thread/composer UI
+- AI SDK UI message streaming over `POST /api/chat`
+- AGX/default provider CLI execution inline in the API route
+
+## Runtime flow
+1. User submits from chat panel composer.
+2. `assistant-ui` transport posts UI messages to `/api/chat` with `scope` + `contextId`.
+3. Route resolves provider/model:
+- `agx.user_settings` default provider/model (preferred)
+- `~/.agx/config.json` default provider fallback
+- final fallback: `claude`
+4. Route runs CLI inline and streams output chunks directly to the thread.
+
+## Files
+- API route: `/Users/mendrika/Projects/Agents/agx-cloud/app/api/chat/route.ts`
+- CLI adapter: `/Users/mendrika/Projects/Agents/agx-cloud/lib/chat/cli-assistant.ts`
+- Runtime wrapper: `/Users/mendrika/Projects/Agents/agx-cloud/components/chat/panel/assistant/AssistantRuntimeLayer.tsx`
+- Thread UI: `/Users/mendrika/Projects/Agents/agx-cloud/components/chat/panel/assistant/AssistantThread.tsx`
+- Composer UI: `/Users/mendrika/Projects/Agents/agx-cloud/components/chat/panel/assistant/AssistantComposer.tsx`
+- Panel shell integration: `/Users/mendrika/Projects/Agents/agx-cloud/components/chat/panel/ChatPanelShell.tsx`
+
+## Notes
+- This route requires Node runtime and should not run on Edge.
+- CLI stderr is captured for errors and not streamed as assistant text.
+- The chat thread renders a runtime-native typing indicator (`ThreadPrimitive.If running`) while the CLI stream is in progress.
+- Deprecated source path from earlier planning: `/Users/mendrika/Projects/Agents/agx/frontend`.

package/cloud-runtime/standalone/instrumentation.ts

@@ -1,13 +1,16 @@
 const SCHEDULE_POLL_INTERVAL_MS = 15_000;
+const PROMPT_JOB_POLL_INTERVAL_MS = 15_000;
 
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     await import("./lib/check-node-version");
     const { getQueue, QUEUE_NAMES } = await import('@/lib/queue/boss');
     const { taskProcessor } = await import('@/lib/orchestrator/processor');
+    const { chatProcessor } = await import('@/lib/orchestrator/chat-processor');
 
     const queue = await getQueue();
     await queue.work(QUEUE_NAMES.TASK_PROCESS, taskProcessor, { batchSize: 5 });
+    await queue.work(QUEUE_NAMES.CHAT_RUN_PROCESS, chatProcessor, { batchSize: 2 });
     console.log('[worker] queue worker started (embedded)');
 
     // Schedule poller — drives recurring graph ticks
@@ -18,6 +21,37 @@ export async function register() {
     const { completeScheduleTick, isScheduleTickComplete } = await import('@/src/graph/schedule');
     const { GraphStore } = await import('@/src/graph/store');
 
+    // Prompt job poller — drives recurring prompt-based scheduled tasks
+    const port = process.env.PORT || '3000';
+    const baseUrl = `http://localhost:${port}`;
+    let promptJobPollReady = false;
+
+    // Wait for the server to be ready before polling prompt jobs
+    setTimeout(() => { promptJobPollReady = true; }, 5_000);
+
+    setInterval(async () => {
+      if (!promptJobPollReady) return;
+      try {
+        const res = await fetch(`${baseUrl}/api/prompt-jobs/poll`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: '{}',
+        });
+        if (res.ok) {
+          const data = await res.json();
+          if (data.queued?.length > 0) {
+            console.log(`[prompt-jobs] dispatched ${data.queued.length} run(s)`);
+          }
+          if (data.skipped?.length > 0) {
+            console.log(`[prompt-jobs] skipped ${data.skipped.length} job(s):`, data.skipped.map((s: any) => s.reason));
+          }
+        }
+      } catch {
+        // Server not ready or network error — ignore
+      }
+    }, PROMPT_JOB_POLL_INTERVAL_MS);
+    console.log(`[prompt-jobs] poller started (every ${PROMPT_JOB_POLL_INTERVAL_MS / 1000}s)`);
+
     setInterval(async () => {
       try {
         const dispatchFunction = createDispatchFunction();

package/cloud-runtime/standalone/mcp/dist/constants.js

@@ -0,0 +1,66 @@
+export const defaultStagePrompts = {
+    ideation: {
+        prompt: "Do the hard work to understand the user's true intent, as they may not know it themselves. Interpret their request and present concrete scenarios to help them visualize options. Iterate until something 'clicks'. It is okay if only 1 out of 10 proposals resonates; the goal is finding that alignment.",
+        outputs: ["research.md"],
+        provider: "gemini",
+        model: "gemini-2.0-flash-thinking-exp",
+        swarm: false,
+    },
+    planning: {
+        prompt: "Translate the aligned intent into an implementation plan.",
+        outputs: ["plan.md", "tasks.md"],
+        provider: "claude",
+        model: "claude-3-5-sonnet-latest",
+        swarm: false,
+    },
+    coding: {
+        prompt: "Implement the plan with clean, reviewed code. Keep changes minimal and well-scoped. Add or update tests as needed. Note any deviations from plan and why.",
+        outputs: ["code", "tests", "PR"],
+        provider: "claude",
+        model: "claude-3-5-sonnet-latest",
+        swarm: false,
+    },
+    qa: {
+        prompt: "Test thoroughly against the acceptance criteria. Cover edge cases and regression risks. Document test results and fix any issues found before proceeding.",
+        outputs: ["test results", "bug fixes"],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+    acceptance: {
+        prompt: "Prepare a concise demo or summary of changes. Verify requirements are met and gather user feedback. Capture approvals or list follow-up actions.",
+        outputs: ["approval", "feedback"],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+    pr: {
+        prompt: "Create and review pull request. Ensure all checks pass and merge. Note any deviations from plan and why.",
+        outputs: ["pull request", "merge commit"],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+    pr_review: {
+        prompt: "Review the PR. Verify code quality and functionality. Approve or request changes.",
+        outputs: ["review comments", "approval"],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+    merge: {
+        prompt: "Merge the PR and verify deployment.",
+        outputs: ["merge", "deployment verification"],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+    done: {
+        prompt: "Task completed. Ensure artifacts are stored, logs are clear, and any follow-ups are recorded.",
+        outputs: [],
+        provider: "gemini",
+        model: "gemini-2.0-flash",
+        swarm: false,
+    },
+};
+//# sourceMappingURL=constants.js.map

package/cloud-runtime/standalone/mcp/dist/db.js

@@ -0,0 +1,220 @@
+import { Pool } from "pg";
+import { config } from "dotenv";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+config({ path: resolve(__dirname, "../../.env") });
+const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+});
+class QueryBuilder {
+    table;
+    operation = "select";
+    filters = [];
+    orderSpecs = [];
+    limitValue = null;
+    selectColumns = "*";
+    payload = null;
+    singleMode = "none";
+    returning = false;
+    constructor(table) {
+        this.table = table;
+    }
+    select(columns = "*") {
+        this.selectColumns = columns || "*";
+        if (this.operation !== "select")
+            this.returning = true;
+        return this;
+    }
+    insert(payload) {
+        this.operation = "insert";
+        this.payload = payload;
+        return this;
+    }
+    update(payload) {
+        this.operation = "update";
+        this.payload = payload;
+        return this;
+    }
+    delete() {
+        this.operation = "delete";
+        return this;
+    }
+    eq(column, value) {
+        this.filters.push({ op: "eq", column, value });
+        return this;
+    }
+    in(column, value) {
+        this.filters.push({ op: "in", column, value });
+        return this;
+    }
+    is(column, value) {
+        this.filters.push({ op: "is", column, value });
+        return this;
+    }
+    order(column, options) {
+        this.orderSpecs.push({ column, ...(options || {}) });
+        return this;
+    }
+    limit(limit) {
+        this.limitValue = limit;
+        return this;
+    }
+    single() {
+        this.singleMode = "single";
+        return this.execute();
+    }
+    maybeSingle() {
+        this.singleMode = "maybeSingle";
+        return this.execute();
+    }
+    then(resolve, reject) {
+        return this.execute().then(resolve, reject);
+    }
+    whereSql(params) {
+        const where = [];
+        for (const f of this.filters) {
+            if (f.op === "eq") {
+                params.push(f.value);
+                where.push(`${f.column} = $${params.length}`);
+            }
+            else if (f.op === "in") {
+                params.push(f.value);
+                where.push(`${f.column} = ANY($${params.length})`);
+            }
+            else if (f.op === "is") {
+                if (f.value === null)
+                    where.push(`${f.column} IS NULL`);
+                else {
+                    params.push(f.value);
+                    where.push(`${f.column} IS NOT DISTINCT FROM $${params.length}`);
+                }
+            }
+        }
+        return where;
+    }
+    normalizeColumns() {
+        if (!this.selectColumns || this.selectColumns.trim() === "*")
+            return "*";
+        return this.selectColumns;
+    }
+    async execute() {
+        try {
+            const params = [];
+            const where = this.whereSql(params);
+            let sql = "";
+            if (this.operation === "select") {
+                sql = `SELECT ${this.normalizeColumns()} FROM ${this.table}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.orderSpecs.length) {
+                    sql +=
+                        " ORDER BY " +
+                            this.orderSpecs
+                                .map((o) => {
+                                const dir = o.ascending === false ? "DESC" : "ASC";
+                                const nulls = o.nullsFirst === true ? " NULLS FIRST" : o.nullsFirst === false ? " NULLS LAST" : "";
+                                return `${o.column} ${dir}${nulls}`;
+                            })
+                                .join(", ");
+                }
+                if (this.limitValue != null) {
+                    params.push(this.limitValue);
+                    sql += ` LIMIT $${params.length}`;
+                }
+            }
+            else if (this.operation === "insert") {
+                const rows = Array.isArray(this.payload) ? this.payload : [this.payload];
+                const cols = Object.keys(rows[0] || {});
+                const valuesSql = rows
+                    .map((row) => {
+                    const placeholders = cols.map((col) => {
+                        params.push(row[col]);
+                        return `$${params.length}`;
+                    });
+                    return `(${placeholders.join(", ")})`;
+                })
+                    .join(", ");
+                sql = `INSERT INTO ${this.table} (${cols.join(", ")}) VALUES ${valuesSql}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            else if (this.operation === "update") {
+                const cols = Object.keys(this.payload || {});
+                const setSql = cols
+                    .map((col) => {
+                    params.push(this.payload[col]);
+                    return `${col} = $${params.length}`;
+                })
+                    .join(", ");
+                sql = `UPDATE ${this.table} SET ${setSql}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            else {
+                sql = `DELETE FROM ${this.table}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            const res = await pool.query(sql, params);
+            const rows = res.rows;
+            if (this.singleMode === "single") {
+                if (!rows.length)
+                    return { data: null, error: { message: "No rows" } };
+                return { data: rows[0], error: null };
+            }
+            if (this.singleMode === "maybeSingle") {
+                return { data: rows[0] || null, error: null };
+            }
+            return { data: rows, error: null };
+        }
+        catch (error) {
+            return { data: null, error };
+        }
+    }
+}
+let db = null;
+export function getSupabase() {
+    if (db)
+        return db;
+    if (!process.env.DATABASE_URL) {
+        throw new Error("Missing DATABASE_URL for MCP server.");
+    }
+    db = {
+        from(table) {
+            return new QueryBuilder(table);
+        },
+    };
+    return db;
+}
+export async function fetchStageConfig(supabase, stage, userId) {
+    let stagePrompt = null;
+    let defaultPrompt = null;
+    const promises = [
+        supabase.from("stage_prompts").select("*").eq("stage", stage).eq("is_default", true).maybeSingle(),
+    ];
+    if (userId) {
+        promises.push(supabase.from("stage_prompts").select("*").eq("stage", stage).eq("user_id", userId).maybeSingle());
+    }
+    const results = await Promise.all(promises);
+    defaultPrompt = results[0].data;
+    if (userId) {
+        stagePrompt = results[1].data;
+    }
+    const resolvedPrompt = stagePrompt?.prompt || defaultPrompt?.prompt || null;
+    if (!resolvedPrompt) {
+        throw new Error(`No prompt found for stage "${stage}" in database (checked user and default).`);
+    }
+    return {
+        prompt: resolvedPrompt,
+        swarm: stagePrompt?.swarm ?? defaultPrompt?.swarm ?? false,
+        provider: stagePrompt?.provider || defaultPrompt?.provider,
+        model: stagePrompt?.model || defaultPrompt?.model,
+        swarm_models: stagePrompt?.swarm_models || defaultPrompt?.swarm_models,
+    };
+}
+//# sourceMappingURL=db.js.map