import { AnyCode } from 'anycode'

const engine = new AnyCode({ defaultModel: 'claude-sonnet-4-6' })

const result = await engine.runAgent(
  {
    name: 'engineer',
    model: 'claude-sonnet-4-6',
    tools: ['bash', 'file_write'],
  },
  'Create a TypeScript utility that checks whether a given string is a palindrome, save it to /tmp/palindrome.ts, and execute it.',
)

console.log(result.output)

import { AnyCode } from 'anycode'
import type { AgentConfig } from 'anycode'

const planner: AgentConfig = {
  name: 'planner',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You draft module interfaces, folder layouts, and endpoint schemas.',
  tools: ['file_write'],
}

const builder: AgentConfig = {
  name: 'builder',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You translate specifications into production-ready code.',
  tools: ['bash', 'file_read', 'file_write', 'file_edit'],
}

const auditor: AgentConfig = {
  name: 'auditor',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You inspect code for bugs, edge cases, and readability concerns.',
  tools: ['file_read', 'grep'],
}

const engine = new AnyCode({
  defaultModel: 'claude-sonnet-4-6',
  onProgress: (ev) => console.log(ev.type, ev.agent ?? ev.task ?? ''),
})

const team = engine.createTeam('backend-crew', {
  name: 'backend-crew',
  agents: [planner, builder, auditor],
  sharedMemory: true,
})

const result = await engine.runTeam(team, 'Scaffold a CRUD API for a notes app in /tmp/notes-api/')

console.log(`Completed: ${result.success}`)
console.log(`Tokens used: ${result.totalTokenUsage.output_tokens}`)

const result = await engine.runTasks(team, [
  {
    title: 'Draft schema definitions',
    description: 'Produce TypeScript type declarations and save them to /tmp/types.md',
    assignee: 'planner',
  },
  {
    title: 'Implement core logic',
    description: 'Read /tmp/types.md and build the service layer in /tmp/lib/',
    assignee: 'builder',
    dependsOn: ['Draft schema definitions'],
  },
  {
    title: 'Write unit tests',
    description: 'Author Vitest test suites covering all service methods.',
    assignee: 'builder',
    dependsOn: ['Implement core logic'],
  },
  {
    title: 'Audit implementation',
    description: 'Examine /tmp/lib/ and generate a detailed review report.',
    assignee: 'auditor',
    dependsOn: ['Implement core logic'],
  },
])

import { z } from 'zod'
import { defineTool, Agent, ToolRegistry, ToolExecutor, registerBuiltInTools } from 'anycode'

const fetchArticles = defineTool({
  name: 'fetch_articles',
  description: 'Retrieves relevant articles from the knowledge base.',
  inputSchema: z.object({
    topic: z.string().describe('Subject to search for.'),
    limit: z.number().optional().describe('Maximum articles to return (default 5).'),
  }),
  execute: async ({ topic, limit = 5 }) => {
    const articles = await myKnowledgeBase(topic, limit)
    return { data: JSON.stringify(articles), isError: false }
  },
})

const registry = new ToolRegistry()
registerBuiltInTools(registry)
registry.register(fetchArticles)

const executor = new ToolExecutor(registry)
const agent = new Agent(
  { name: 'analyst', model: 'claude-sonnet-4-6', tools: ['fetch_articles'] },
  registry,
  executor,
)

const result = await agent.run('Summarize the latest changes in the ECMAScript specification.')

const thinker: AgentConfig = {
  name: 'thinker',
  model: 'claude-opus-4-6',
  provider: 'anthropic',
  systemPrompt: 'You devise architectural blueprints and technical strategies.',
  tools: ['file_write'],
}

const implementer: AgentConfig = {
  name: 'implementer',
  model: 'gpt-5.4',
  provider: 'openai',
  systemPrompt: 'You transform plans into functional, tested code.',
  tools: ['bash', 'file_read', 'file_write'],
}

const team = engine.createTeam('cross-provider', {
  name: 'cross-provider',
  agents: [thinker, implementer],
  sharedMemory: true,
})

await engine.runTeam(team, 'Create a CLI utility that transforms YAML files into JSON format.')

import { Agent, ToolRegistry, ToolExecutor, registerBuiltInTools } from 'anycode'

const registry = new ToolRegistry()
registerBuiltInTools(registry)
const executor = new ToolExecutor(registry)

const narrator = new Agent(
  { name: 'narrator', model: 'claude-sonnet-4-6', maxTurns: 3 },
  registry,
  executor,
)

for await (const ev of narrator.stream('Describe the observer pattern in three sentences.')) {
  if (ev.type === 'text' && typeof ev.data === 'string') {
    process.stdout.write(ev.data)
  }
}