struere 0.3.0

package/dist/cli/index.js

@@ -0,0 +1,2126 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/index.ts
+import { program } from "commander";
+
+// src/cli/commands/init.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4, basename } from "path";
+
+// src/cli/utils/credentials.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".struere");
+var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function saveCredentials(credentials) {
+  ensureConfigDir();
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function loadCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(CREDENTIALS_FILE, "utf-8");
+    const credentials = JSON.parse(data);
+    if (new Date(credentials.expiresAt) < new Date) {
+      clearCredentials();
+      return null;
+    }
+    return credentials;
+  } catch {
+    return null;
+  }
+}
+function clearCredentials() {
+  if (existsSync(CREDENTIALS_FILE)) {
+    unlinkSync(CREDENTIALS_FILE);
+  }
+}
+function getApiKey() {
+  const credentials = loadCredentials();
+  if (credentials?.apiKey) {
+    return credentials.apiKey;
+  }
+  return process.env.STRUERE_API_KEY || null;
+}
+
+// src/cli/commands/login.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/cli/utils/convex.ts
+var CONVEX_URL = process.env.STRUERE_CONVEX_URL || "https://struere.convex.cloud";
+async function syncToConvex(agentId, config) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "agents:syncDevelopment",
+      args: {
+        agentId,
+        config
+      }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { success: false, error };
+  }
+  const result = await response.json();
+  return { success: result.success ?? true };
+}
+async function deployToProduction(agentId) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "agents:deploy",
+      args: { agentId }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { success: false, error };
+  }
+  const result = await response.json();
+  return { success: result.success ?? true, configId: result.configId };
+}
+async function listAgents() {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { agents: [], error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "agents:list",
+      args: {}
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { agents: [], error };
+  }
+  const result = await response.json();
+  const agents = Array.isArray(result) ? result : result?.value || [];
+  return { agents };
+}
+async function createAgent(data) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "agents:create",
+      args: data
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { error };
+  }
+  const agentId = await response.json();
+  return { agentId };
+}
+async function getUserInfo(token) {
+  const response = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "users:getCurrent",
+      args: {}
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { error };
+  }
+  const user = await response.json();
+  if (!user) {
+    return { error: "User not found" };
+  }
+  const orgResponse = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "organizations:getCurrent",
+      args: {}
+    })
+  });
+  if (!orgResponse.ok) {
+    return { error: "Failed to fetch organization" };
+  }
+  const org = await orgResponse.json();
+  return {
+    userInfo: {
+      user: {
+        id: user._id,
+        email: user.email,
+        name: user.name,
+        organizationId: user.organizationId
+      },
+      organization: {
+        id: org._id,
+        name: org.name,
+        slug: org.slug
+      }
+    }
+  };
+}
+function extractConfig(agent) {
+  const BUILTIN_TOOLS = [
+    "entity.create",
+    "entity.get",
+    "entity.query",
+    "entity.update",
+    "entity.delete",
+    "entity.link",
+    "entity.unlink",
+    "event.emit",
+    "event.query",
+    "job.enqueue",
+    "job.status"
+  ];
+  let systemPrompt;
+  if (typeof agent.systemPrompt === "function") {
+    const result = agent.systemPrompt();
+    if (result instanceof Promise) {
+      throw new Error("Async system prompts must be resolved before syncing");
+    }
+    systemPrompt = result;
+  } else {
+    systemPrompt = agent.systemPrompt;
+  }
+  const tools = (agent.tools || []).map((tool) => {
+    const isBuiltin = BUILTIN_TOOLS.includes(tool.name);
+    let handlerCode;
+    if (!isBuiltin && tool.handler) {
+      handlerCode = extractHandlerCode(tool.handler);
+    }
+    return {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters || { type: "object", properties: {} },
+      handlerCode,
+      isBuiltin
+    };
+  });
+  return {
+    name: agent.name,
+    version: agent.version || "0.0.1",
+    systemPrompt,
+    model: {
+      provider: agent.model?.provider || "anthropic",
+      name: agent.model?.name || "claude-sonnet-4-20250514",
+      temperature: agent.model?.temperature,
+      maxTokens: agent.model?.maxTokens
+    },
+    tools
+  };
+}
+function extractHandlerCode(handler) {
+  const code = handler.toString();
+  const arrowMatch = code.match(/(?:async\s*)?\([^)]*\)\s*=>\s*\{?([\s\S]*)\}?$/);
+  if (arrowMatch) {
+    let body = arrowMatch[1].trim();
+    if (body.startsWith("{") && body.endsWith("}")) {
+      body = body.slice(1, -1).trim();
+    }
+    return body;
+  }
+  const funcMatch = code.match(/(?:async\s*)?function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/);
+  if (funcMatch) {
+    return funcMatch[1].trim();
+  }
+  return code;
+}
+async function getRecentExecutions(limit = 100) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { executions: [], error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "executions:list",
+      args: { limit }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { executions: [], error };
+  }
+  const executions = await response.json();
+  return { executions: executions || [] };
+}
+async function getThreadState(threadId) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/query`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "threads:getWithMessages",
+      args: { threadId }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { error };
+  }
+  const state = await response.json();
+  if (!state) {
+    return { error: "Thread not found" };
+  }
+  return { state };
+}
+async function runTestConversation(agentId, message, threadId) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  const token = apiKey || credentials?.token;
+  if (!token) {
+    return { error: "Not authenticated" };
+  }
+  const response = await fetch(`${CONVEX_URL}/api/action`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      path: "agent:chat",
+      args: {
+        agentId,
+        message,
+        threadId,
+        environment: "development"
+      }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    return { error };
+  }
+  const result = await response.json();
+  return {
+    response: {
+      message: result.message,
+      toolCalls: result.toolCalls
+    },
+    threadId: result.threadId
+  };
+}
+
+// src/cli/commands/login.ts
+var AUTH_CALLBACK_PORT = 9876;
+var loginCommand = new Command("login").description("Log in to Struere").action(async () => {
+  const spinner = ora();
+  console.log();
+  console.log(chalk.bold("Struere Login"));
+  console.log();
+  const existing = loadCredentials();
+  if (existing) {
+    console.log(chalk.yellow("Already logged in as"), chalk.cyan(existing.user.email));
+    console.log(chalk.gray("Run"), chalk.cyan("struere logout"), chalk.gray("to log out first"));
+    console.log();
+    return;
+  }
+  await browserLogin(spinner);
+});
+async function performLogin() {
+  const spinner = ora();
+  console.log();
+  console.log(chalk.bold("Struere Login"));
+  console.log();
+  return browserLoginInternal(spinner);
+}
+async function browserLogin(spinner) {
+  const result = await browserLoginInternal(spinner);
+  if (result) {
+    printNextSteps();
+  }
+}
+async function browserLoginInternal(spinner) {
+  spinner.start("Starting authentication server");
+  const authPromise = new Promise((resolve, reject) => {
+    const server = Bun.serve({
+      port: AUTH_CALLBACK_PORT,
+      async fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/callback") {
+          const token = url.searchParams.get("token");
+          const sessionId = url.searchParams.get("session_id");
+          if (token && sessionId) {
+            resolve({ token, sessionId });
+            setTimeout(() => server.stop(), 1000);
+            return new Response(getSuccessHtml(), {
+              headers: { "Content-Type": "text/html" }
+            });
+          }
+          return new Response(getErrorHtml("Missing token"), {
+            status: 400,
+            headers: { "Content-Type": "text/html" }
+          });
+        }
+        if (url.pathname === "/") {
+          const authUrl = getAuthUrl();
+          return Response.redirect(authUrl, 302);
+        }
+        return new Response("Not Found", { status: 404 });
+      }
+    });
+    setTimeout(() => {
+      server.stop();
+      reject(new Error("Authentication timed out"));
+    }, 5 * 60 * 1000);
+  });
+  spinner.succeed("Authentication server started");
+  const loginUrl = `http://localhost:${AUTH_CALLBACK_PORT}`;
+  console.log();
+  console.log(chalk.gray("Opening browser to log in..."));
+  console.log(chalk.gray("If browser does not open, visit:"), chalk.cyan(loginUrl));
+  console.log();
+  if (process.platform === "darwin") {
+    Bun.spawn(["open", loginUrl]);
+  } else if (process.platform === "linux") {
+    Bun.spawn(["xdg-open", loginUrl]);
+  } else if (process.platform === "win32") {
+    Bun.spawn(["cmd", "/c", "start", loginUrl]);
+  }
+  spinner.start("Waiting for authentication");
+  try {
+    const { token } = await authPromise;
+    spinner.text = "Fetching user info";
+    const { userInfo, error } = await getUserInfo(token);
+    if (error || !userInfo) {
+      throw new Error(error || "Failed to fetch user info");
+    }
+    const { user, organization } = userInfo;
+    const credentials = {
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name || user.email,
+        organizationId: user.organizationId
+      },
+      organization: {
+        id: organization.id,
+        name: organization.name,
+        slug: organization.slug
+      },
+      expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString()
+    };
+    saveCredentials(credentials);
+    spinner.succeed("Logged in successfully");
+    console.log();
+    console.log(chalk.green("Welcome,"), chalk.cyan(user.name || user.email));
+    console.log(chalk.gray("Organization:"), organization.name);
+    console.log();
+    return credentials;
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.log();
+    console.log(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    return null;
+  }
+}
+function printNextSteps() {
+  console.log(chalk.gray("You can now use:"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere dev"), chalk.gray("- Start cloud-connected dev server"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere deploy"), chalk.gray("- Deploy your agent"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere logs"), chalk.gray("- View agent logs"));
+  console.log();
+}
+function getAuthUrl() {
+  const baseUrl = process.env.STRUERE_AUTH_URL || "https://app.struere.dev";
+  const callbackUrl = `http://localhost:${AUTH_CALLBACK_PORT}/callback`;
+  return `${baseUrl}/authorize?callback=${encodeURIComponent(callbackUrl)}`;
+}
+function getSuccessHtml() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Login Successful</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+    .container { text-align: center; }
+    h1 { color: #22c55e; }
+    p { color: #888; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Login Successful</h1>
+    <p>You can close this window and return to the terminal.</p>
+  </div>
+  <script>setTimeout(() => window.close(), 3000)</script>
+</body>
+</html>`;
+}
+function getErrorHtml(message) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Login Failed</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+    .container { text-align: center; }
+    h1 { color: #ef4444; }
+    p { color: #888; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Login Failed</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+}
+
+// src/cli/utils/project.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var PROJECT_FILE = "struere.json";
+function loadProject(cwd) {
+  const projectPath = join2(cwd, PROJECT_FILE);
+  if (!existsSync2(projectPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync2(projectPath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveProject(cwd, project) {
+  const projectPath = join2(cwd, PROJECT_FILE);
+  writeFileSync2(projectPath, JSON.stringify(project, null, 2) + `
+`);
+}
+function hasProject(cwd) {
+  return existsSync2(join2(cwd, PROJECT_FILE));
+}
+
+// src/cli/utils/scaffold.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/cli/templates/index.ts
+function getPackageJson(name) {
+  return JSON.stringify({
+    name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "struere dev",
+      build: "struere build",
+      test: "struere test",
+      deploy: "struere deploy"
+    },
+    dependencies: {
+      struere: "^0.3.0"
+    },
+    devDependencies: {
+      "bun-types": "^1.0.0",
+      typescript: "^5.3.0"
+    }
+  }, null, 2);
+}
+function getTsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      lib: ["ES2022"],
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      outDir: "dist",
+      rootDir: "src",
+      types: ["bun-types"]
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2);
+}
+function getStruereConfig() {
+  return `import { defineConfig } from 'struere'
+
+export default defineConfig({
+  port: 3000,
+  host: 'localhost',
+  cors: {
+    origins: ['http://localhost:3000'],
+    credentials: true,
+  },
+  logging: {
+    level: 'info',
+    format: 'pretty',
+  },
+})
+`;
+}
+function getAgentTs(name) {
+  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return `import { defineAgent } from 'struere'
+import { context } from './context'
+import { tools } from './tools'
+
+export default defineAgent({
+  name: '${name}',
+  version: '0.1.0',
+  description: '${displayName} Agent',
+  model: {
+    provider: 'anthropic',
+    name: 'claude-sonnet-4-20250514',
+    temperature: 0.7,
+    maxTokens: 4096,
+  },
+  systemPrompt: \`You are ${displayName}, a helpful AI assistant.
+
+Your capabilities:
+- Answer questions accurately and helpfully
+- Use available tools when appropriate
+- Maintain conversation context
+
+Always be concise, accurate, and helpful.\`,
+  tools,
+  context,
+  state: {
+    storage: 'memory',
+    ttl: 3600,
+  },
+})
+`;
+}
+function getContextTs() {
+  return `import { defineContext } from 'struere'
+
+export const context = defineContext(async (request) => {
+  const { conversationId, userId, channel, state } = request
+
+  return {
+    additionalContext: \`
+Current conversation: \${conversationId}
+Channel: \${channel}
+\`,
+    variables: {
+      userId,
+      timestamp: new Date().toISOString(),
+    },
+  }
+})
+`;
+}
+function getToolsTs() {
+  return `import { defineTools } from 'struere'
+
+export const tools = defineTools([
+  {
+    name: 'get_current_time',
+    description: 'Get the current date and time',
+    parameters: {
+      type: 'object',
+      properties: {
+        timezone: {
+          type: 'string',
+          description: 'Timezone (e.g., "America/New_York", "UTC")',
+        },
+      },
+    },
+    handler: async (params) => {
+      const timezone = (params.timezone as string) || 'UTC'
+      const now = new Date()
+      return {
+        timestamp: now.toISOString(),
+        formatted: now.toLocaleString('en-US', { timeZone: timezone }),
+        timezone,
+      }
+    },
+  },
+  {
+    name: 'calculate',
+    description: 'Perform a mathematical calculation',
+    parameters: {
+      type: 'object',
+      properties: {
+        expression: {
+          type: 'string',
+          description: 'Mathematical expression to evaluate (e.g., "2 + 2")',
+        },
+      },
+      required: ['expression'],
+    },
+    handler: async (params) => {
+      const expression = params.expression as string
+      const sanitized = expression.replace(/[^0-9+*/().\\s-]/g, '')
+      try {
+        const result = new Function(\`return \${sanitized}\`)()
+        return { expression, result }
+      } catch {
+        return { expression, error: 'Invalid expression' }
+      }
+    },
+  },
+])
+`;
+}
+function getBasicTestYaml() {
+  return `name: Basic conversation test
+description: Verify the agent responds correctly to basic queries
+
+conversation:
+  - role: user
+    content: Hello, what can you do?
+  - role: assistant
+    assertions:
+      - type: contains
+        value: help
+
+  - role: user
+    content: What time is it?
+  - role: assistant
+    assertions:
+      - type: toolCalled
+        value: get_current_time
+`;
+}
+function getEnvExample() {
+  return `# Anthropic API Key (default provider)
+ANTHROPIC_API_KEY=your_api_key_here
+
+# Optional: OpenAI API Key (if using OpenAI models)
+# OPENAI_API_KEY=your_openai_api_key
+
+# Optional: Google AI API Key (if using Gemini models)
+# GOOGLE_GENERATIVE_AI_API_KEY=your_google_api_key
+
+# Optional: Custom Convex URL
+# STRUERE_CONVEX_URL=https://struere.convex.cloud
+`;
+}
+function getGitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+.env.*.local
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+*.log
+logs/
+.vercel/
+`;
+}
+function getStruereJson(agentId, team, slug, name) {
+  return JSON.stringify({
+    agentId,
+    team,
+    agent: {
+      slug,
+      name
+    }
+  }, null, 2);
+}
+function getEnvLocal(deploymentUrl) {
+  return `STRUERE_DEPLOYMENT_URL=${deploymentUrl}
+`;
+}
+
+// src/cli/utils/scaffold.ts
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function writeFile(cwd, relativePath, content) {
+  const fullPath = join3(cwd, relativePath);
+  ensureDir(fullPath);
+  writeFileSync3(fullPath, content);
+}
+function writeProjectConfig(cwd, options) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  writeFile(cwd, "struere.json", getStruereJson(options.agentId, options.team, options.agentSlug, options.agentName));
+  result.createdFiles.push("struere.json");
+  writeFile(cwd, ".env.local", getEnvLocal(options.deploymentUrl));
+  result.createdFiles.push(".env.local");
+  updateGitignore(cwd, result);
+  return result;
+}
+function scaffoldAgentFiles(cwd, projectName) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  const files = {
+    "package.json": getPackageJson(projectName),
+    "tsconfig.json": getTsConfig(),
+    "struere.config.ts": getStruereConfig(),
+    "src/agent.ts": getAgentTs(projectName),
+    "src/context.ts": getContextTs(),
+    "src/tools.ts": getToolsTs(),
+    "src/workflows/.gitkeep": "",
+    "tests/basic.test.yaml": getBasicTestYaml(),
+    ".env.example": getEnvExample()
+  };
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = join3(cwd, relativePath);
+    if (existsSync3(fullPath)) {
+      continue;
+    }
+    writeFile(cwd, relativePath, content);
+    result.createdFiles.push(relativePath);
+  }
+  updateGitignore(cwd, result);
+  return result;
+}
+function updateGitignore(cwd, result) {
+  const gitignorePath = join3(cwd, ".gitignore");
+  const linesToAdd = [".env.local"];
+  if (existsSync3(gitignorePath)) {
+    const content = readFileSync3(gitignorePath, "utf-8");
+    const lines = content.split(`
+`);
+    const missingLines = linesToAdd.filter((line) => !lines.some((l) => l.trim() === line));
+    if (missingLines.length > 0) {
+      const toAppend = `
+` + missingLines.join(`
+`) + `
+`;
+      appendFileSync(gitignorePath, toAppend);
+      result.updatedFiles.push(".gitignore");
+    }
+  } else {
+    writeFile(cwd, ".gitignore", getGitignore());
+    result.createdFiles.push(".gitignore");
+  }
+}
+function hasAgentFiles(cwd) {
+  return existsSync3(join3(cwd, "src", "agent.ts"));
+}
+
+// src/cli/commands/init.ts
+var initCommand = new Command2("init").description("Initialize a new Struere project").argument("[project-name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").action(async (projectNameArg, options) => {
+  const cwd = process.cwd();
+  const spinner = ora2();
+  console.log();
+  console.log(chalk2.bold("Struere CLI"));
+  console.log();
+  if (hasProject(cwd)) {
+    const existingProject = loadProject(cwd);
+    if (existingProject) {
+      console.log(chalk2.yellow("This project is already initialized."));
+      console.log();
+      console.log(chalk2.gray("  Agent:"), chalk2.cyan(existingProject.agent.name));
+      console.log(chalk2.gray("  ID:"), chalk2.gray(existingProject.agentId));
+      console.log(chalk2.gray("  Team:"), chalk2.cyan(existingProject.team));
+      console.log();
+      const shouldRelink = await promptYesNo("Would you like to relink to a different agent?");
+      if (!shouldRelink) {
+        console.log();
+        console.log(chalk2.gray("Run"), chalk2.cyan("struere dev"), chalk2.gray("to start development"));
+        console.log();
+        return;
+      }
+    }
+  }
+  let credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk2.gray("Authentication required"));
+    console.log();
+    credentials = await performLogin();
+    if (!credentials) {
+      console.log(chalk2.red("Authentication failed"));
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk2.green("\u2713"), "Logged in as", chalk2.cyan(credentials.user.name || credentials.user.email));
+    console.log();
+  }
+  let projectName = projectNameArg;
+  if (!projectName) {
+    projectName = await deriveProjectName(cwd);
+    if (!options.yes) {
+      const confirmed = await promptText("Agent name:", projectName);
+      projectName = confirmed || projectName;
+    }
+  }
+  projectName = slugify(projectName);
+  spinner.start("Fetching agents");
+  const { agents: existingAgents, error: listError } = await listAgents();
+  if (listError) {
+    spinner.fail("Failed to fetch agents");
+    console.log();
+    console.log(chalk2.gray("Run"), chalk2.cyan("struere login"), chalk2.gray("to re-authenticate"));
+    process.exit(1);
+  }
+  const agents = existingAgents.map((a) => ({ id: a._id, name: a.name, slug: a.slug }));
+  spinner.succeed(`Found ${agents.length} existing agent(s)`);
+  let selectedAgent = null;
+  let deploymentUrl = "";
+  if (agents.length > 0 && !options.yes) {
+    console.log();
+    const choice = await promptChoice("Create new agent or link existing?", [
+      { value: "new", label: "Create new agent" },
+      ...agents.map((a) => ({ value: a.id, label: `${a.name} (${a.slug})` }))
+    ]);
+    if (choice !== "new") {
+      selectedAgent = agents.find((a) => a.id === choice) || null;
+    }
+  }
+  if (!selectedAgent) {
+    const displayName = projectName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    spinner.start("Creating agent");
+    const { agentId, error: createError } = await createAgent({
+      name: displayName,
+      slug: projectName,
+      description: `${displayName} Agent`
+    });
+    if (createError || !agentId) {
+      spinner.fail("Failed to create agent");
+      console.log();
+      console.log(chalk2.red("Error:"), createError || "Unknown error");
+      process.exit(1);
+    }
+    selectedAgent = { id: agentId, name: displayName, slug: projectName };
+    deploymentUrl = `https://${projectName}-dev.struere.dev`;
+    spinner.succeed(`Created agent "${projectName}"`);
+  } else {
+    deploymentUrl = `https://${selectedAgent.slug}-dev.struere.dev`;
+    console.log();
+    console.log(chalk2.green("\u2713"), `Linked to "${selectedAgent.name}"`);
+  }
+  saveProject(cwd, {
+    agentId: selectedAgent.id,
+    team: credentials.organization.slug,
+    agent: {
+      slug: selectedAgent.slug,
+      name: selectedAgent.name
+    }
+  });
+  console.log(chalk2.green("\u2713"), "Created struere.json");
+  const configResult = writeProjectConfig(cwd, {
+    projectName,
+    agentId: selectedAgent.id,
+    team: credentials.organization.slug,
+    agentSlug: selectedAgent.slug,
+    agentName: selectedAgent.name,
+    deploymentUrl
+  });
+  for (const file of configResult.createdFiles) {
+    if (file !== "struere.json") {
+      console.log(chalk2.green("\u2713"), `Created ${file}`);
+    }
+  }
+  for (const file of configResult.updatedFiles) {
+    console.log(chalk2.green("\u2713"), `Updated ${file}`);
+  }
+  if (!hasAgentFiles(cwd)) {
+    let shouldScaffold = options.yes;
+    if (!options.yes) {
+      console.log();
+      shouldScaffold = await promptYesNo("Scaffold starter files?");
+    }
+    if (shouldScaffold) {
+      const scaffoldResult = scaffoldAgentFiles(cwd, projectName);
+      console.log();
+      for (const file of scaffoldResult.createdFiles) {
+        console.log(chalk2.green("\u2713"), `Created ${file}`);
+      }
+      for (const file of scaffoldResult.updatedFiles) {
+        console.log(chalk2.green("\u2713"), `Updated ${file}`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk2.green("Success!"), "Project initialized");
+  console.log();
+  console.log(chalk2.gray("Next steps:"));
+  console.log(chalk2.gray("  $"), chalk2.cyan("bun install"));
+  console.log(chalk2.gray("  $"), chalk2.cyan("struere dev"));
+  console.log();
+});
+async function deriveProjectName(cwd) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (existsSync4(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+      if (pkg.name && typeof pkg.name === "string") {
+        return slugify(pkg.name);
+      }
+    } catch {}
+  }
+  return slugify(basename(cwd));
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function promptYesNo(message) {
+  process.stdout.write(chalk2.gray(`${message} (Y/n) `));
+  const answer = await readLine();
+  return answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+async function promptText(message, defaultValue) {
+  process.stdout.write(chalk2.gray(`${message} `));
+  process.stdout.write(chalk2.cyan(`(${defaultValue}) `));
+  const answer = await readLine();
+  return answer || defaultValue;
+}
+async function promptChoice(message, choices) {
+  console.log(chalk2.gray(message));
+  console.log();
+  for (let i = 0;i < choices.length; i++) {
+    const prefix = i === 0 ? chalk2.cyan("\u276F") : chalk2.gray(" ");
+    console.log(`${prefix} ${i + 1}. ${choices[i].label}`);
+  }
+  console.log();
+  process.stdout.write(chalk2.gray("Enter choice (1-" + choices.length + "): "));
+  const answer = await readLine();
+  const num = parseInt(answer, 10);
+  if (num >= 1 && num <= choices.length) {
+    return choices[num - 1].value;
+  }
+  return choices[0].value;
+}
+function readLine() {
+  return new Promise((resolve) => {
+    let buffer = "";
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    const onData = (data) => {
+      buffer += data;
+      if (buffer.includes(`
+`)) {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        resolve(buffer.replace(/[\r\n]/g, "").trim());
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/cli/commands/dev.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import chokidar from "chokidar";
+import { join as join7, basename as basename2 } from "path";
+
+// src/cli/utils/config.ts
+import { join as join5 } from "path";
+var defaultConfig = {
+  port: 3000,
+  host: "localhost",
+  cors: {
+    origins: ["http://localhost:3000"],
+    credentials: true
+  },
+  logging: {
+    level: "info",
+    format: "pretty"
+  },
+  auth: {
+    type: "none"
+  }
+};
+async function loadConfig(cwd) {
+  const configPath = join5(cwd, "struere.config.ts");
+  try {
+    const module = await import(configPath);
+    const config = module.default || module;
+    return {
+      ...defaultConfig,
+      ...config,
+      cors: {
+        ...defaultConfig.cors,
+        ...config.cors
+      },
+      logging: {
+        ...defaultConfig.logging,
+        ...config.logging
+      },
+      auth: {
+        ...defaultConfig.auth,
+        ...config.auth
+      }
+    };
+  } catch {
+    return defaultConfig;
+  }
+}
+
+// src/cli/utils/agent.ts
+import { join as join6 } from "path";
+async function loadAgent(cwd) {
+  const agentPath = join6(cwd, "src/agent.ts");
+  try {
+    const module = await import(agentPath);
+    const agent = module.default || module;
+    if (!agent.name) {
+      throw new Error("Agent must have a name");
+    }
+    if (!agent.version) {
+      throw new Error("Agent must have a version");
+    }
+    if (!agent.systemPrompt) {
+      throw new Error("Agent must have a systemPrompt");
+    }
+    return agent;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(`Agent not found at ${agentPath}`);
+    }
+    throw error;
+  }
+}
+
+// src/cli/commands/dev.ts
+var devCommand = new Command3("dev").description("Sync agent to development environment").action(async () => {
+  const spinner = ora3();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk3.bold("Struere Dev"));
+  console.log();
+  let project = loadProject(cwd);
+  if (!hasProject(cwd)) {
+    console.log(chalk3.yellow("No struere.json found"));
+    console.log();
+    const setupResult = await interactiveSetup(cwd);
+    if (!setupResult) {
+      process.exit(0);
+    }
+    project = setupResult;
+  }
+  project = loadProject(cwd);
+  if (!project) {
+    console.log(chalk3.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  console.log(chalk3.gray("Agent:"), chalk3.cyan(project.agent.name));
+  console.log();
+  spinner.start("Loading configuration");
+  await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  let agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    spinner.fail("Not logged in");
+    console.log();
+    console.log(chalk3.gray("Run"), chalk3.cyan("struere login"), chalk3.gray("to authenticate"));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Syncing to Convex");
+  const performSync = async () => {
+    try {
+      const config = extractConfig(agent);
+      const result = await syncToConvex(project.agentId, config);
+      if (!result.success) {
+        throw new Error(result.error || "Sync failed");
+      }
+      return true;
+    } catch (error) {
+      throw error;
+    }
+  };
+  try {
+    await performSync();
+    spinner.succeed("Synced to development");
+  } catch (error) {
+    spinner.fail("Sync failed");
+    console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  const devUrl = `https://${project.agent.slug}-dev.struere.dev`;
+  console.log();
+  console.log(chalk3.green("Development URL:"), chalk3.cyan(devUrl));
+  console.log();
+  console.log(chalk3.gray("Watching for changes... Press Ctrl+C to stop"));
+  console.log();
+  const watcher = chokidar.watch([join7(cwd, "src"), join7(cwd, "struere.config.ts")], {
+    ignoreInitial: true,
+    ignored: /node_modules/
+  });
+  watcher.on("change", async (path) => {
+    const relativePath = path.replace(cwd, ".");
+    console.log(chalk3.gray(`Changed: ${relativePath}`));
+    const syncSpinner = ora3("Syncing...").start();
+    try {
+      agent = await loadAgent(cwd);
+      await performSync();
+      syncSpinner.succeed("Synced");
+    } catch (error) {
+      syncSpinner.fail("Sync failed");
+      console.log(chalk3.red("Error:"), error instanceof Error ? error.message : String(error));
+    }
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    watcher.close();
+    console.log(chalk3.gray("Stopped"));
+    process.exit(0);
+  });
+});
+async function interactiveSetup(cwd) {
+  const spinner = ora3();
+  let credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk3.gray("Authentication required"));
+    console.log();
+    credentials = await performLogin();
+    if (!credentials) {
+      console.log(chalk3.red("Authentication failed"));
+      return null;
+    }
+  } else {
+    console.log(chalk3.green("\u2713"), "Logged in as", chalk3.cyan(credentials.user.name));
+    console.log();
+  }
+  spinner.start("Fetching agents");
+  const { agents: existingAgents, error: listError } = await listAgents();
+  if (listError) {
+    spinner.fail("Failed to fetch agents");
+    console.log();
+    console.log(chalk3.gray("Run"), chalk3.cyan("struere login"), chalk3.gray("to re-authenticate"));
+    return null;
+  }
+  const agents = existingAgents.map((a) => ({ id: a._id, name: a.name, slug: a.slug }));
+  spinner.succeed(`Found ${agents.length} existing agent(s)`);
+  let selectedAgent = null;
+  if (agents.length === 0) {
+    console.log(chalk3.gray("No existing agents found. Creating a new one..."));
+  } else {
+    console.log();
+    const choices = [
+      { value: "link", label: "Link to an existing agent" },
+      { value: "create", label: "Create a new agent" },
+      { value: "cancel", label: "Cancel" }
+    ];
+    const action = await promptChoiceArrows("No agent configured. Would you like to:", choices);
+    if (action === "cancel") {
+      console.log();
+      console.log(chalk3.gray("Run"), chalk3.cyan("struere init"), chalk3.gray("when ready to set up"));
+      return null;
+    }
+    if (action === "link") {
+      console.log();
+      const agentChoices = agents.map((a) => ({ value: a.id, label: `${a.name} (${a.slug})` }));
+      const agentId = await promptChoiceArrows("Select an agent:", agentChoices);
+      selectedAgent = agents.find((a) => a.id === agentId) || null;
+    }
+  }
+  if (!selectedAgent) {
+    console.log();
+    const projectName = slugify2(basename2(cwd));
+    const name = await promptText2("Agent name:", projectName);
+    const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    spinner.start("Creating agent");
+    const { agentId, error: createError } = await createAgent({
+      name: displayName,
+      slug: name,
+      description: `${displayName} Agent`
+    });
+    if (createError || !agentId) {
+      spinner.fail("Failed to create agent");
+      console.log();
+      console.log(chalk3.red("Error:"), createError || "Unknown error");
+      return null;
+    }
+    selectedAgent = { id: agentId, name: displayName, slug: name };
+    spinner.succeed(`Created agent "${name}"`);
+  }
+  if (!selectedAgent) {
+    return null;
+  }
+  const projectData = {
+    agentId: selectedAgent.id,
+    team: credentials.organization.slug,
+    agent: {
+      slug: selectedAgent.slug,
+      name: selectedAgent.name
+    }
+  };
+  saveProject(cwd, projectData);
+  console.log(chalk3.green("\u2713"), "Created struere.json");
+  if (!hasAgentFiles(cwd)) {
+    const scaffoldResult = scaffoldAgentFiles(cwd, selectedAgent.slug);
+    for (const file of scaffoldResult.createdFiles) {
+      console.log(chalk3.green("\u2713"), `Created ${file}`);
+    }
+    console.log();
+    console.log(chalk3.yellow("Run"), chalk3.cyan("bun install"), chalk3.yellow("to install dependencies"));
+  }
+  console.log();
+  return projectData;
+}
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function promptChoiceArrows(message, choices) {
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+    const render = () => {
+      process.stdout.write("\x1B[?25l");
+      process.stdout.write(`\x1B[${choices.length + 2}A`);
+      console.log(chalk3.gray(message));
+      console.log();
+      for (let i = 0;i < choices.length; i++) {
+        const prefix = i === selectedIndex ? chalk3.cyan("\u276F") : " ";
+        const label = i === selectedIndex ? chalk3.cyan(choices[i].label) : choices[i].label;
+        console.log(`${prefix} ${label}`);
+      }
+    };
+    console.log(chalk3.gray(message));
+    console.log();
+    for (let i = 0;i < choices.length; i++) {
+      const prefix = i === selectedIndex ? chalk3.cyan("\u276F") : " ";
+      const label = i === selectedIndex ? chalk3.cyan(choices[i].label) : choices[i].label;
+      console.log(`${prefix} ${label}`);
+    }
+    if (!process.stdin.isTTY) {
+      resolve(choices[0].value);
+      return;
+    }
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    const onKeypress = (key) => {
+      const char = key.toString();
+      if (char === "\x1B[A" || char === "k") {
+        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        render();
+      } else if (char === "\x1B[B" || char === "j") {
+        selectedIndex = (selectedIndex + 1) % choices.length;
+        render();
+      } else if (char === "\r" || char === `
+`) {
+        process.stdin.removeListener("data", onKeypress);
+        process.stdin.setRawMode?.(false);
+        process.stdin.pause();
+        process.stdout.write("\x1B[?25h");
+        resolve(choices[selectedIndex].value);
+      } else if (char === "\x03") {
+        process.stdin.removeListener("data", onKeypress);
+        process.stdin.setRawMode?.(false);
+        process.stdout.write("\x1B[?25h");
+        process.exit(0);
+      }
+    };
+    process.stdin.on("data", onKeypress);
+  });
+}
+async function promptText2(message, defaultValue) {
+  process.stdout.write(chalk3.gray(`${message} `));
+  process.stdout.write(chalk3.cyan(`(${defaultValue}) `));
+  const answer = await readLine2();
+  return answer || defaultValue;
+}
+function readLine2() {
+  return new Promise((resolve) => {
+    let buffer = "";
+    const onData = (chunk) => {
+      const str = chunk.toString();
+      buffer += str;
+      if (str.includes(`
+`) || str.includes("\r")) {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        process.stdin.setRawMode?.(false);
+        resolve(buffer.replace(/[\r\n]/g, "").trim());
+      }
+    };
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode?.(false);
+    }
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/cli/commands/build.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { join as join8 } from "path";
+
+// src/cli/utils/validate.ts
+function validateAgent(agent) {
+  const errors = [];
+  if (!agent.name) {
+    errors.push("Agent name is required");
+  } else if (!/^[a-z0-9-]+$/.test(agent.name)) {
+    errors.push("Agent name must be lowercase alphanumeric with hyphens only");
+  }
+  if (!agent.version) {
+    errors.push("Agent version is required");
+  } else if (!/^\d+\.\d+\.\d+/.test(agent.version)) {
+    errors.push("Agent version must follow semver format (e.g., 1.0.0)");
+  }
+  if (!agent.systemPrompt) {
+    errors.push("System prompt is required");
+  } else if (typeof agent.systemPrompt === "string" && agent.systemPrompt.trim().length === 0) {
+    errors.push("System prompt cannot be empty");
+  }
+  if (agent.model) {
+    const validProviders = ["anthropic", "openai", "google", "custom"];
+    if (!validProviders.includes(agent.model.provider)) {
+      errors.push(`Invalid model provider: ${agent.model.provider}`);
+    }
+    if (!agent.model.name) {
+      errors.push("Model name is required when model is specified");
+    }
+    if (agent.model.temperature !== undefined) {
+      if (agent.model.temperature < 0 || agent.model.temperature > 2) {
+        errors.push("Model temperature must be between 0 and 2");
+      }
+    }
+    if (agent.model.maxTokens !== undefined) {
+      if (agent.model.maxTokens < 1) {
+        errors.push("Model maxTokens must be at least 1");
+      }
+    }
+  }
+  if (agent.tools) {
+    for (const tool of agent.tools) {
+      const toolErrors = validateTool(tool);
+      errors.push(...toolErrors);
+    }
+  }
+  if (agent.state) {
+    const validStorage = ["memory", "redis", "postgres", "custom"];
+    if (!validStorage.includes(agent.state.storage)) {
+      errors.push(`Invalid state storage: ${agent.state.storage}`);
+    }
+    if (agent.state.ttl !== undefined && agent.state.ttl < 0) {
+      errors.push("State TTL must be non-negative");
+    }
+  }
+  return errors;
+}
+function validateTool(tool) {
+  const errors = [];
+  if (!tool.name) {
+    errors.push("Tool name is required");
+  } else if (!/^[a-z_][a-z0-9_]*$/.test(tool.name)) {
+    errors.push(`Tool name "${tool.name}" must be snake_case`);
+  }
+  if (!tool.description) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a description`);
+  }
+  if (!tool.parameters) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires parameters definition`);
+  } else if (tool.parameters.type !== "object") {
+    errors.push(`Tool "${tool.name || "unknown"}" parameters type must be "object"`);
+  }
+  if (typeof tool.handler !== "function") {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a handler function`);
+  }
+  return errors;
+}
+
+// src/cli/commands/build.ts
+var buildCommand = new Command4("build").description("Build and validate agent for production").option("-o, --outdir <dir>", "Output directory", "dist").action(async (options) => {
+  const spinner = ora4();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk4.bold("Building Agent"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk4.red("  \u2717"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  spinner.start("Building");
+  const outdir = join8(cwd, options.outdir);
+  const result = await Bun.build({
+    entrypoints: [join8(cwd, "src/agent.ts")],
+    outdir,
+    target: "node",
+    minify: true
+  });
+  if (!result.success) {
+    spinner.fail("Build failed");
+    console.log();
+    for (const log of result.logs) {
+      console.log(chalk4.red("  \u2717"), log.message);
+    }
+    process.exit(1);
+  }
+  spinner.succeed("Build completed");
+  console.log();
+  console.log(chalk4.green("Success!"), `Built to ${chalk4.cyan(options.outdir)}`);
+  console.log();
+  console.log("Output files:");
+  for (const output of result.outputs) {
+    console.log(chalk4.gray("  \u2022"), output.path.replace(cwd, "."));
+  }
+  console.log();
+});
+
+// src/cli/commands/test.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora5 from "ora";
+import { join as join9 } from "path";
+import { readdir, readFile } from "fs/promises";
+import YAML from "yaml";
+var testCommand = new Command5("test").description("Run test conversations").argument("[pattern]", "Test file pattern", "*.test.yaml").option("-v, --verbose", "Show detailed output").option("--dry-run", "Parse tests without executing (no API calls)").action(async (pattern, options) => {
+  const spinner = ora5();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk5.bold("Running Tests"));
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk5.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk5.gray("Run"), chalk5.cyan("struere init"), chalk5.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProject(cwd);
+  if (!project) {
+    console.log(chalk5.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Finding test files");
+  const testsDir = join9(cwd, "tests");
+  let testFiles = [];
+  try {
+    const files = await readdir(testsDir);
+    testFiles = files.filter((f) => f.endsWith(".test.yaml") || f.endsWith(".test.yml"));
+  } catch {
+    spinner.warn("No tests directory found");
+    console.log();
+    console.log(chalk5.gray("Create tests in"), chalk5.cyan("tests/*.test.yaml"));
+    console.log();
+    return;
+  }
+  if (testFiles.length === 0) {
+    spinner.warn("No test files found");
+    console.log();
+    return;
+  }
+  spinner.succeed(`Found ${testFiles.length} test file(s)`);
+  if (options.dryRun) {
+    console.log();
+    console.log(chalk5.yellow("Dry run mode - skipping execution"));
+    console.log();
+  }
+  const results = [];
+  for (const file of testFiles) {
+    const filePath = join9(testsDir, file);
+    const content = await readFile(filePath, "utf-8");
+    const testCase = YAML.parse(content);
+    if (options.verbose) {
+      console.log();
+      console.log(chalk5.gray("Running:"), testCase.name);
+    }
+    const result = options.dryRun ? await runDryTest(testCase) : await runTest(testCase, project.agentId, options.verbose);
+    results.push(result);
+    if (result.passed) {
+      console.log(chalk5.green("  \u2713"), result.name);
+    } else {
+      console.log(chalk5.red("  \u2717"), result.name);
+      for (const error of result.errors) {
+        console.log(chalk5.red("    \u2192"), error);
+      }
+    }
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log();
+  if (failed === 0) {
+    console.log(chalk5.green("All tests passed!"), chalk5.gray(`(${passed}/${results.length})`));
+  } else {
+    console.log(chalk5.red("Tests failed:"), chalk5.gray(`${passed}/${results.length} passed`));
+  }
+  console.log();
+  if (failed > 0) {
+    process.exit(1);
+  }
+});
+async function runDryTest(testCase) {
+  return {
+    name: testCase.name,
+    passed: true,
+    errors: []
+  };
+}
+async function runTest(testCase, agentId, verbose) {
+  const errors = [];
+  let threadId;
+  const context = {
+    lastResponse: "",
+    toolCalls: [],
+    state: {}
+  };
+  try {
+    for (const message of testCase.conversation || []) {
+      if (message.role === "user") {
+        if (verbose) {
+          console.log(chalk5.cyan("    User:"), message.content.slice(0, 50) + (message.content.length > 50 ? "..." : ""));
+        }
+        const { response, threadId: newThreadId, error } = await runTestConversation(agentId, message.content, threadId);
+        if (error || !response) {
+          errors.push(`API error: ${error || "Unknown error"}`);
+          break;
+        }
+        threadId = newThreadId;
+        context.lastResponse = response.message;
+        context.toolCalls = response.toolCalls || [];
+        if (verbose) {
+          console.log(chalk5.green("    Assistant:"), response.message.slice(0, 50) + (response.message.length > 50 ? "..." : ""));
+          if (response.toolCalls && response.toolCalls.length > 0) {
+            console.log(chalk5.yellow("    Tools:"), response.toolCalls.map((t) => t.name).join(", "));
+          }
+        }
+      }
+      if (message.assertions) {
+        for (const assertion of message.assertions) {
+          const passed = checkAssertion(assertion, context);
+          if (!passed) {
+            errors.push(formatAssertionError(assertion, context));
+          }
+        }
+      }
+    }
+    if (testCase.assertions) {
+      for (const assertion of testCase.assertions) {
+        const passed = checkAssertion(assertion, context);
+        if (!passed) {
+          errors.push(formatAssertionError(assertion, context));
+        }
+      }
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    errors.push(`Execution error: ${errorMsg}`);
+  }
+  return {
+    name: testCase.name,
+    passed: errors.length === 0,
+    errors
+  };
+}
+function checkAssertion(assertion, context) {
+  switch (assertion.type) {
+    case "contains":
+      return typeof assertion.value === "string" && context.lastResponse.toLowerCase().includes(assertion.value.toLowerCase());
+    case "matches":
+      return typeof assertion.value === "string" && new RegExp(assertion.value, "i").test(context.lastResponse);
+    case "toolCalled":
+      if (typeof assertion.value === "string") {
+        return context.toolCalls.some((tc) => tc.name === assertion.value);
+      }
+      return false;
+    case "stateEquals":
+      if (typeof assertion.value === "object" && assertion.value !== null) {
+        for (const [key, expected] of Object.entries(assertion.value)) {
+          if (context.state[key] !== expected) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function formatAssertionError(assertion, context) {
+  switch (assertion.type) {
+    case "contains":
+      return `Expected response to contain "${assertion.value}", got: "${context.lastResponse.slice(0, 100)}..."`;
+    case "matches":
+      return `Expected response to match /${assertion.value}/, got: "${context.lastResponse.slice(0, 100)}..."`;
+    case "toolCalled":
+      const calledTools = context.toolCalls.map((tc) => tc.name).join(", ") || "none";
+      return `Expected tool "${assertion.value}" to be called, called: [${calledTools}]`;
+    case "stateEquals":
+      return `State mismatch: expected ${JSON.stringify(assertion.value)}, got ${JSON.stringify(context.state)}`;
+    default:
+      return `Assertion failed: ${assertion.type} - ${JSON.stringify(assertion.value)}`;
+  }
+}
+
+// src/cli/commands/deploy.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora6 from "ora";
+var deployCommand = new Command6("deploy").description("Deploy agent to production").option("--dry-run", "Show what would be deployed without deploying").action(async (options) => {
+  const environment = "production";
+  const spinner = ora6();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk6.bold("Deploying Agent"));
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk6.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk6.gray("Run"), chalk6.cyan("struere init"), chalk6.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProject(cwd);
+  if (!project) {
+    console.log(chalk6.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  console.log(chalk6.gray("Agent:"), chalk6.cyan(project.agent.name));
+  console.log();
+  spinner.start("Loading configuration");
+  await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk6.red("  x"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  if (options.dryRun) {
+    console.log();
+    console.log(chalk6.yellow("Dry run mode - no changes will be made"));
+    console.log();
+    console.log("Would deploy:");
+    console.log(chalk6.gray("  -"), `Agent: ${chalk6.cyan(agent.name)}`);
+    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(agent.version)}`);
+    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(environment)}`);
+    console.log(chalk6.gray("  -"), `Agent ID: ${chalk6.cyan(project.agentId)}`);
+    console.log();
+    return;
+  }
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    spinner.fail("Not authenticated");
+    console.log();
+    console.log(chalk6.gray("Run"), chalk6.cyan("struere login"), chalk6.gray("to authenticate"));
+    console.log(chalk6.gray("Or set"), chalk6.cyan("STRUERE_API_KEY"), chalk6.gray("environment variable"));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Extracting agent configuration");
+  const config = extractConfig(agent);
+  spinner.succeed("Configuration extracted");
+  spinner.start("Syncing to development");
+  try {
+    const syncResult = await syncToConvex(project.agentId, config);
+    if (!syncResult.success) {
+      throw new Error(syncResult.error || "Sync failed");
+    }
+    spinner.succeed("Synced to development");
+  } catch (error) {
+    spinner.fail("Sync failed");
+    console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  spinner.start(`Deploying to ${environment}`);
+  try {
+    const deployResult = await deployToProduction(project.agentId);
+    if (!deployResult.success) {
+      throw new Error(deployResult.error || "Deployment failed");
+    }
+    spinner.succeed(`Deployed to ${environment}`);
+    const prodUrl = `https://${project.agent.slug}.struere.dev`;
+    console.log();
+    console.log(chalk6.green("Success!"), "Agent deployed");
+    console.log();
+    console.log("Deployment details:");
+    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(agent.version)}`);
+    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(environment)}`);
+    console.log(chalk6.gray("  -"), `URL: ${chalk6.cyan(prodUrl)}`);
+    console.log();
+    console.log(chalk6.gray("Test your agent:"));
+    console.log(chalk6.gray("  $"), chalk6.cyan(`curl -X POST ${prodUrl}/chat -H "Authorization: Bearer YOUR_API_KEY" -d '{"message": "Hello"}'`));
+    console.log();
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    console.log();
+    console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    console.log(chalk6.gray("Try running"), chalk6.cyan("struere login"), chalk6.gray("to re-authenticate"));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/validate.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora7 from "ora";
+var validateCommand = new Command7("validate").description("Validate agent configuration").option("--strict", "Enable strict validation").action(async (options) => {
+  const spinner = ora7();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk7.bold("Validating Agent"));
+  console.log();
+  spinner.start("Loading agent");
+  let agent;
+  try {
+    agent = await loadAgent(cwd);
+    spinner.succeed(`Agent "${agent.name}" loaded`);
+  } catch (error) {
+    spinner.fail("Failed to load agent");
+    console.log();
+    console.log(chalk7.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Validating configuration");
+  const errors = validateAgent(agent);
+  const warnings = options.strict ? getStrictWarnings(agent) : [];
+  if (errors.length === 0 && warnings.length === 0) {
+    spinner.succeed("Agent is valid");
+    console.log();
+    console.log(chalk7.green("\u2713"), "No issues found");
+    console.log();
+    return;
+  }
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    console.log(chalk7.red("Errors:"));
+    for (const error of errors) {
+      console.log(chalk7.red("  \u2717"), error);
+    }
+  } else {
+    spinner.succeed("Validation passed with warnings");
+  }
+  if (warnings.length > 0) {
+    console.log();
+    console.log(chalk7.yellow("Warnings:"));
+    for (const warning of warnings) {
+      console.log(chalk7.yellow("  \u26A0"), warning);
+    }
+  }
+  console.log();
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+});
+function getStrictWarnings(agent) {
+  const warnings = [];
+  if (!agent.description) {
+    warnings.push("Agent is missing a description");
+  }
+  if (!agent.tools || agent.tools.length === 0) {
+    warnings.push("Agent has no tools defined");
+  }
+  return warnings;
+}
+
+// src/cli/commands/logs.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora8 from "ora";
+var logsCommand = new Command8("logs").description("View recent execution logs").option("-n, --lines <number>", "Number of executions to show", "50").option("--json", "Output as JSON").action(async (options) => {
+  const spinner = ora8();
+  console.log();
+  console.log(chalk8.bold("Execution Logs"));
+  console.log();
+  spinner.start("Fetching recent executions");
+  const { executions, error } = await getRecentExecutions(parseInt(options.lines, 10));
+  if (error) {
+    spinner.fail("Failed to fetch executions");
+    console.log();
+    console.log(chalk8.red("Error:"), error);
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed(`Fetched ${executions.length} executions`);
+  console.log();
+  if (options.json) {
+    console.log(JSON.stringify(executions, null, 2));
+    console.log();
+    return;
+  }
+  if (executions.length === 0) {
+    console.log(chalk8.gray("No executions found"));
+    console.log();
+    return;
+  }
+  for (const exec of executions) {
+    const statusColor = exec.status === "success" ? chalk8.green : chalk8.red;
+    const timestamp = new Date(exec.createdAt).toISOString();
+    console.log(chalk8.gray(timestamp), statusColor(`[${exec.status}]`), chalk8.cyan(`${exec.inputTokens}/${exec.outputTokens} tokens`), chalk8.gray(`${exec.durationMs}ms`));
+    if (exec.errorMessage) {
+      console.log(chalk8.red(`  Error: ${exec.errorMessage}`));
+    }
+  }
+  console.log();
+});
+
+// src/cli/commands/state.ts
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+import ora9 from "ora";
+var stateCommand = new Command9("state").description("Inspect conversation thread state").argument("<id>", "Thread ID").option("--json", "Output as JSON").action(async (id, options) => {
+  const spinner = ora9();
+  console.log();
+  console.log(chalk9.bold("Thread State"));
+  console.log();
+  spinner.start("Fetching thread state");
+  const { state, error } = await getThreadState(id);
+  if (error) {
+    spinner.fail("Failed to fetch state");
+    console.log();
+    console.log(chalk9.red("Error:"), error);
+    console.log();
+    process.exit(1);
+  }
+  if (!state) {
+    spinner.fail("Thread not found");
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("State retrieved");
+  if (options.json) {
+    console.log();
+    console.log(JSON.stringify(state, null, 2));
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(chalk9.gray("Thread:"), chalk9.cyan(state.thread._id));
+  console.log(chalk9.gray("Agent:"), state.thread.agentId);
+  console.log(chalk9.gray("Created:"), new Date(state.thread.createdAt).toLocaleString());
+  console.log(chalk9.gray("Updated:"), new Date(state.thread.updatedAt).toLocaleString());
+  console.log(chalk9.gray("Messages:"), state.messages.length);
+  console.log();
+  if (state.messages.length > 0) {
+    console.log(chalk9.bold("Messages:"));
+    console.log();
+    for (const msg of state.messages) {
+      const roleColor = msg.role === "user" ? chalk9.blue : msg.role === "assistant" ? chalk9.green : chalk9.gray;
+      console.log(roleColor(`[${msg.role}]`));
+      console.log(msg.content.slice(0, 200) + (msg.content.length > 200 ? "..." : ""));
+      console.log();
+    }
+  }
+});
+
+// src/cli/commands/logout.ts
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+var logoutCommand = new Command10("logout").description("Log out of Struere").action(async () => {
+  console.log();
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk10.yellow("Not currently logged in"));
+    console.log();
+    return;
+  }
+  clearCredentials();
+  console.log(chalk10.green("Logged out successfully"));
+  console.log(chalk10.gray("Goodbye,"), chalk10.cyan(credentials.user.name));
+  console.log();
+});
+
+// src/cli/commands/whoami.ts
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+import ora10 from "ora";
+var whoamiCommand = new Command11("whoami").description("Show current logged in user").option("--refresh", "Refresh user info from server").action(async (options) => {
+  console.log();
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk11.yellow("Not logged in"));
+    console.log();
+    console.log(chalk11.gray("Run"), chalk11.cyan("struere login"), chalk11.gray("to log in"));
+    console.log();
+    return;
+  }
+  if (options.refresh) {
+    const spinner = ora10("Fetching user info").start();
+    const { userInfo, error } = await getUserInfo(credentials.token);
+    if (error || !userInfo) {
+      spinner.fail("Failed to fetch user info");
+      console.log();
+      if (error?.includes("401") || error?.includes("unauthorized")) {
+        console.log(chalk11.red("Session expired. Please log in again."));
+      } else {
+        console.log(chalk11.red("Error:"), error || "Unknown error");
+      }
+      console.log();
+      process.exit(1);
+    }
+    spinner.stop();
+    const { user, organization } = userInfo;
+    console.log(chalk11.bold("Logged in as:"));
+    console.log();
+    console.log(chalk11.gray("  User:        "), chalk11.cyan(user.name || user.email), chalk11.gray(`<${user.email}>`));
+    console.log(chalk11.gray("  User ID:     "), chalk11.gray(user.id));
+    console.log();
+    console.log(chalk11.gray("  Organization:"), chalk11.cyan(organization.name));
+    console.log(chalk11.gray("  Org ID:      "), chalk11.gray(organization.id));
+    console.log(chalk11.gray("  Slug:        "), chalk11.cyan(organization.slug));
+    console.log();
+  } else {
+    console.log(chalk11.bold("Logged in as:"));
+    console.log();
+    console.log(chalk11.gray("  User:        "), chalk11.cyan(credentials.user.name), chalk11.gray(`<${credentials.user.email}>`));
+    console.log(chalk11.gray("  User ID:     "), chalk11.gray(credentials.user.id));
+    console.log();
+    console.log(chalk11.gray("  Organization:"), chalk11.cyan(credentials.organization.name));
+    console.log(chalk11.gray("  Org ID:      "), chalk11.gray(credentials.organization.id));
+    console.log(chalk11.gray("  Slug:        "), chalk11.cyan(credentials.organization.slug));
+    console.log();
+    console.log(chalk11.gray("Use"), chalk11.cyan("struere whoami --refresh"), chalk11.gray("to fetch latest info"));
+    console.log();
+  }
+});
+
+// src/cli/index.ts
+var CURRENT_VERSION = "0.3.0";
+async function checkForUpdates() {
+  if (process.env.STRUERE_SKIP_UPDATE_CHECK)
+    return;
+  try {
+    const response = await fetch("https://registry.npmjs.org/struere/latest", {
+      signal: AbortSignal.timeout(2000)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.version !== CURRENT_VERSION) {
+        const semverCompare = (a, b) => {
+          const pa = a.split(".").map(Number);
+          const pb = b.split(".").map(Number);
+          for (let i = 0;i < 3; i++) {
+            if (pa[i] > pb[i])
+              return 1;
+            if (pa[i] < pb[i])
+              return -1;
+          }
+          return 0;
+        };
+        if (semverCompare(data.version, CURRENT_VERSION) > 0) {
+          console.log(`\x1B[33m\u26A0 Update available: ${CURRENT_VERSION} \u2192 ${data.version}\x1B[0m`);
+          console.log(`\x1B[90m  Run: npm install -g struere@${data.version}\x1B[0m`);
+          console.log();
+        }
+      }
+    }
+  } catch {}
+}
+checkForUpdates();
+program.name("struere").description("Struere CLI - Build, test, and deploy AI agents").version(CURRENT_VERSION);
+program.addCommand(initCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(testCommand);
+program.addCommand(deployCommand);
+program.addCommand(validateCommand);
+program.addCommand(logsCommand);
+program.addCommand(stateCommand);
+program.parse();