🔨 Criar Estrutura Base

# Inicializar o projeto completo
mkdir meu-saas-agentes && cd meu-saas-agentes
git init

# .gitignore robusto
cat > .gitignore << 'EOF'
# Dependencies
node_modules/
.pnpm-store/

# Environment
.env
.env.local
.env.production

# Build
dist/
.next/
.turbo/
out/

# Secrets
*.pem
*.key
credentials.json
service-account.json

# IDE
.vscode/settings.json
.idea/

# OS
.DS_Store
Thumbs.db

# Logs
*.log
npm-debug.log*

# Database local
*.sqlite
*.db
EOF

# README minimo
cat > README.md << 'EOF'
# Meu SaaS de Agentes

Plataforma de agentes de IA com Next.js, Supabase e multiplos provedores.

## Setup
```bash
cp .env.example .env  # Preencher com suas chaves
npm install
npm run dev
```

## Variaveis de Ambiente
Ver `.env.example` para a lista completa.
EOF

# Primeiro commit
git add .gitignore README.md
git commit -m "chore: init repo com gitignore e readme"

# Conectar ao GitHub
gh repo create meu-saas-agentes --private --source=. --push

# Scaffold completo com mkdir -p
mkdir -p app/api/chat app/api/agents app/(dashboard)
mkdir -p agents
mkdir -p prompts/agents prompts/templates
mkdir -p skills
mkdir -p tools
mkdir -p memory/migrations
mkdir -p config
mkdir -p lib/utils
mkdir -p types

# Index files (barrel exports)
cat > agents/index.ts << 'EOF'
export { SimpleAgent } from './simple';
export type { Agent, AgentConfig, AgentResponse } from '../types/agent';
EOF

cat > tools/index.ts << 'EOF'
export { webSearch } from './web-search';
export { readFile } from './file-read';
export type { Tool, ToolResult } from '../types/tool';
EOF

cat > config/index.ts << 'EOF'
export { env } from './env';
export { providers } from './providers';
EOF

# Types compartilhados
cat > types/agent.ts << 'EOF'
export interface Agent {
  id: string;
  name: string;
  run(input: string, context?: AgentContext): Promise<AgentResponse>;
}

export interface AgentConfig {
  provider: 'openai' | 'anthropic' | 'ollama';
  model: string;
  systemPrompt: string;
  temperature?: number;
  maxTokens?: number;
}

export interface AgentResponse {
  text: string;
  usage: { promptTokens: number; completionTokens: number; cost: number };
  latencyMs: number;
}

export interface AgentContext {
  history: Array<{ role: string; content: string }>;
  userPrefs?: Record<string, string>;
}
EOF

# Global system prompt
cat > prompts/global.md << 'EOF'
Voce e um assistente inteligente. Responda de forma clara e direta.
Nao use emojis excessivos. Seja preciso e util.
Se nao souber algo, diga que nao sabe.
EOF

echo "Scaffold completo. $(find . -type f | wc -l) arquivos criados."

# Criar Next.js app com TypeScript + Tailwind
npx create-next-app@latest . --typescript --tailwind --eslint \
  --app --src-dir --import-alias "@/*" --no-git

# Dependencias de producao
npm install @supabase/supabase-js   # Banco de dados
npm install openai                   # OpenAI SDK
npm install @anthropic-ai/sdk        # Anthropic SDK
npm install zod                      # Validacao runtime
npm install ai                       # Vercel AI SDK (streaming)

# DevDependencies
npm install -D @types/node prettier

# package.json scripts
{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint",
    "type-check": "tsc --noEmit",
    "db:migrate": "supabase db push",
    "db:reset": "supabase db reset",
    "db:types": "supabase gen types typescript --local > types/database.ts"
  }
}

# Verificar tudo instalou correto
npm run type-check  # Zero errors = pronto
npm run dev         # Server rodando em localhost:3000

-- Migracao inicial: create tables
-- Arquivo: memory/migrations/001_initial.sql

-- Profiles (extende auth.users)
CREATE TABLE profiles (
  id UUID PRIMARY KEY REFERENCES auth.users(id) ON DELETE CASCADE,
  name TEXT,
  preferences JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Agents
CREATE TABLE agents (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  provider TEXT NOT NULL CHECK (provider IN ('openai', 'anthropic', 'ollama')),
  model TEXT NOT NULL,
  system_prompt TEXT,
  temperature REAL DEFAULT 0.7,
  max_tokens INT DEFAULT 4096,
  is_active BOOLEAN DEFAULT true,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Conversations
CREATE TABLE conversations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES profiles(id) ON DELETE CASCADE,
  agent_id TEXT REFERENCES agents(id),
  title TEXT,
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);

-- Messages
CREATE TABLE messages (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  conversation_id UUID REFERENCES conversations(id) ON DELETE CASCADE,
  role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
  content TEXT NOT NULL,
  tokens_used INT DEFAULT 0,
  cost_usd DECIMAL(10, 6) DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Indices para queries frequentes
CREATE INDEX idx_messages_conversation ON messages(conversation_id, created_at);
CREATE INDEX idx_conversations_user ON conversations(user_id, updated_at DESC);

-- Seed: primeiro agente
INSERT INTO agents (id, name, provider, model, system_prompt)
VALUES ('simple', 'Agente Simples', 'openai', 'gpt-4o-mini',
  'Voce e um assistente util. Responda de forma clara e direta.');

// agents/simple.ts
import OpenAI from 'openai';
import type { Agent, AgentConfig, AgentContext, AgentResponse } from '@/types/agent';

const COST_PER_1K = { 'gpt-4o-mini': { input: 0.00015, output: 0.0006 } };

export class SimpleAgent implements Agent {
  id = 'simple';
  name = 'Agente Simples';
  private client: OpenAI;
  private config: AgentConfig;

  constructor(config?: Partial<AgentConfig>) {
    this.config = {
      provider: 'openai',
      model: 'gpt-4o-mini',
      systemPrompt: 'Voce e um assistente util. Responda de forma clara.',
      temperature: 0.7,
      maxTokens: 4096,
      ...config,
    };
    this.client = new OpenAI(); // Usa OPENAI_API_KEY do env
  }

  async run(input: string, context?: AgentContext): Promise<AgentResponse> {
    const start = Date.now();

    // Montar messages
    const messages: OpenAI.ChatCompletionMessageParam[] = [
      { role: 'system', content: this.config.systemPrompt },
      ...(context?.history || []).map(h => ({
        role: h.role as 'user' | 'assistant',
        content: h.content,
      })),
      { role: 'user', content: input },
    ];

    // Chamar o provedor
    const completion = await this.client.chat.completions.create({
      model: this.config.model,
      messages,
      temperature: this.config.temperature,
      max_tokens: this.config.maxTokens,
    });

    const text = completion.choices[0]?.message?.content || '';
    const usage = completion.usage;
    const model = this.config.model as keyof typeof COST_PER_1K;
    const pricing = COST_PER_1K[model] || { input: 0, output: 0 };

    return {
      text,
      usage: {
        promptTokens: usage?.prompt_tokens || 0,
        completionTokens: usage?.completion_tokens || 0,
        cost: ((usage?.prompt_tokens || 0) / 1000 * pricing.input) +
              ((usage?.completion_tokens || 0) / 1000 * pricing.output),
      },
      latencyMs: Date.now() - start,
    };
  }
}

// Teste rapido
// npx tsx agents/simple.ts
if (require.main === module) {
  const agent = new SimpleAgent();
  agent.run('O que e uma plataforma de agentes de IA?').then(r => {
    console.log('Resposta:', r.text);
    console.log('Tokens:', r.usage.promptTokens, '+', r.usage.completionTokens);
    console.log('Custo: $' + r.usage.cost.toFixed(6));
    console.log('Latencia:', r.latencyMs + 'ms');
  });
}

// app/api/chat/route.ts - API Route completa
import { NextResponse } from 'next/server';
import { z } from 'zod';
import { SimpleAgent } from '@/agents/simple';
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_ANON_KEY!
);

const chatSchema = z.object({
  message: z.string().min(1).max(10000),
  conversationId: z.string().uuid().optional(),
});

export async function POST(req: Request) {
  try {
    const body = await req.json();
    const { message, conversationId } = chatSchema.parse(body);

    // Criar ou reusar conversa
    let convId = conversationId;
    if (!convId) {
      const { data } = await supabase
        .from('conversations')
        .insert({ agent_id: 'simple', title: message.slice(0, 50) })
        .select('id')
        .single();
      convId = data?.id;
    }

    // Buscar historico
    const { data: history } = await supabase
      .from('messages')
      .select('role, content')
      .eq('conversation_id', convId)
      .order('created_at', { ascending: true })
      .limit(20);

    // Salvar mensagem do usuario
    await supabase.from('messages').insert({
      conversation_id: convId,
      role: 'user',
      content: message,
    });

    // Chamar agente
    const agent = new SimpleAgent();
    const result = await agent.run(message, { history: history || [] });

    // Salvar resposta
    await supabase.from('messages').insert({
      conversation_id: convId,
      role: 'assistant',
      content: result.text,
      tokens_used: result.usage.promptTokens + result.usage.completionTokens,
      cost_usd: result.usage.cost,
    });

    return NextResponse.json({
      text: result.text,
      conversationId: convId,
      usage: result.usage,
    });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json({ error: error.errors }, { status: 400 });
    }
    console.error('Chat error:', error);
    return NextResponse.json(
      { error: 'Erro interno. Tente novamente.' },
      { status: 500 }
    );
  }
}

# Checklist de deploy
# 1. git add . && git commit -m "feat: MVP completo com agente e chat"
# 2. git push origin main
# 3. vercel (ou conectar via vercel.com dashboard)
# 4. Configurar env vars no Vercel
# 5. Acessar URL publica e testar
# 6. Verificar dados no Supabase dashboard