import { Claude } from "smithers-orchestrator";

<Claude
  model="sonnet"
  maxTurns={10}
  onFinished={(result) => console.log(result.output)}
>
  Analyze this codebase and suggest improvements.
</Claude>

interface AgentResult<T = any> {
  output: string;              // Raw text output
  structured?: T;              // Validated structured output
  tokensUsed: {
    input: number;
    output: number;
  };
  turnsUsed: number;
  stopReason: 'completed' | 'stop_condition' | 'error' | 'cancelled';
  durationMs: number;
  exitCode?: number;
  sessionId?: string;
}

import { z } from 'zod';

const AnalysisSchema = z.object({
  summary: z.string(),
  issues: z.array(z.object({
    severity: z.enum(['low', 'medium', 'high', 'critical']),
    file: z.string(),
    description: z.string(),
  })),
  recommendations: z.array(z.string()),
});

<Claude
  model="sonnet"
  schema={AnalysisSchema}
  maxRetries={2}
  onFinished={(result) => {
    // result.structured is typed as z.infer<typeof AnalysisSchema>
    for (const issue of result.structured.issues) {
      console.log(`[${issue.severity}] ${issue.file}: ${issue.description}`);
    }
  }}
>
  Analyze this codebase for security issues.
  Return a structured analysis.
</Claude>

// Research only - no modifications
<Claude allowedTools={["Read", "Glob", "Grep"]}>
  Find all files that import the auth module.
</Claude>

// Full edit access
<Claude
  allowedTools={["Read", "Edit", "Write", "Bash"]}
  permissionMode="acceptEdits"
>
  Implement the feature.
</Claude>

// No shell access
<Claude disallowedTools={["Bash"]}>
  Analyze the code (no commands).
</Claude>

function ConditionalClaude() {
  const { db, reactiveDb } = useSmithers();
  
  const phase = useQueryValue<string>(
    reactiveDb,
    "SELECT value FROM state WHERE key = 'phase'"
  ) ?? "research";
  
  const setPhase = (p: string) => db.state.set('phase', p);

  return (
    <SmithersProvider db={db} executionId={executionId} maxIterations={5}>
      <If condition={phase === "research"}>
        <Claude
          allowedTools={["Read", "Glob"]}
          onFinished={() => setPhase("implement")}
        >
          Research the codebase.
        </Claude>
      </If>

      <If condition={phase === "implement"}>
        <Claude
          allowedTools={["Edit", "Write"]}
          onFinished={() => setPhase("done")}
        >
          Implement the solution.
        </Claude>
      </If>
    </SmithersProvider>
  );
}

<Claude model="sonnet">
  <Sqlite path="./data.db">
    Database contains users and orders tables.
  </Sqlite>

  Find the top 10 customers by order value.
  Export results to a CSV file.
</Claude>

function ResilientClaude() {
  const { db, reactiveDb } = useSmithers();
  
  const attempts = useQueryValue<number>(
    reactiveDb,
    "SELECT value FROM state WHERE key = 'attempts'"
  ) ?? 0;
  
  const error = useQueryValue<string | null>(
    reactiveDb,
    "SELECT value FROM state WHERE key = 'error'"
  ) ?? null;

  return (
    <SmithersProvider db={db} executionId={executionId} maxIterations={3}>
      <If condition={error !== null && attempts < 3}>
        <Claude
          onFinished={() => db.state.set('error', null)}
          onError={(err) => {
            db.state.set('error', err.message);
            db.state.set('attempts', attempts + 1);
          }}
        >
          Previous attempt failed: {error}
          Try a different approach.
        </Claude>
      </If>

      <If condition={error === null}>
        <Claude
          onFinished={(r) => console.log("Success:", r.output)}
          onError={(err) => db.state.set('error', err.message)}
        >
          Complete the task.
        </Claude>
      </If>
    </SmithersProvider>
  );
}