import { runAgentLoop } from '@nexrall/code-core/agent';
import type { AgentLoopOptions } from '@nexrall/code-core';

const messages = [
  { role: 'user', content: [{ type: 'text', text: 'List the files in src/ and summarise what this project does.' }] }
];

const opts: AgentLoopOptions = {
  model: 'turbo',          // 'turbo' (Sonnet) | 'pro' (Opus) | 'ultra' (Fable 5)
  workDir: process.cwd(),
  env: { platform: 'node', cwd: process.cwd(), shell: 'bash' },
  clientType: 'cli',
  mode: 'auto',
  onText:       (t) => process.stdout.write(t),
  onThinking:   () => {},
  onThinkingDelta:    () => {},
  onThinkingProgress: () => {},
  onToolUse:    (name, input) => console.error(`[tool] ${name}`, input),
  onToolResult: (name, res)   => console.error(`[tool result] ${name}`, res.error ?? '✓'),
  onInjectedInput: () => {},
  onUsage:      () => {},
  requestPermission: async () => true,   // auto-approve everything
};

const history = await runAgentLoop(messages, opts);
console.log('Done —', history.length, 'messages');

interface AgentLoopOptions {
  model: 'turbo' | 'pro' | 'ultra';
  workDir: string;
  env: EnvContext;
  clientType?: 'cli' | 'vscode';
  mode?: 'auto' | 'ask' | 'edit' | 'plan';
  effort?: 'low' | 'medium' | 'high' | 'extra';
  nexrallMd?: string;            // project instructions (nexrall.md contents)
  maxIterations?: number;        // default 500, ceiling 2000
  autoContinue?: boolean;        // auto-extend budget when agent is mid-task (default: true)
  autoCompact?: boolean;         // auto-summarise history at 80% context window (default: true)
  abortSignal?: { aborted: boolean };
  checkpointManager?: CheckpointManager;
  mcpManager?: McpManager;
  // Stream callbacks
  onText: (text: string) => void;
  onThinking: (text: string) => void;
  onThinkingDelta: (text: string) => void;
  onThinkingProgress: (tokens: number) => void;
  onToolUse: (name: string, input: Record<string, unknown>, isSubTask?: boolean) => void;
  onToolResult: (name: string, result: ToolResult, isSubTask?: boolean) => void;
  onInjectedInput: (text: string) => void;
  onUsage: (usage: UsageStats) => void;
  requestPermission: (req: PermissionRequest) => Promise<boolean>;
  // Optional: inject follow-up messages while the agent is running
  takePendingInput?: () => string[];
  // Optional: handle tools not in the built-in executor (e.g. VS Code LSP tools)
  executeExternalTool?: (name: string, input: Record<string, unknown>) => Promise<ToolResult | null>;
}

import { loadPlugins, pluginHooks, pluginMcpServers } from '@nexrall/code-core/plugins';

const plugins = loadPlugins(process.cwd());
// [{ name: 'my-plugin', version: '1.0.0', dir: '...', scope: 'project' }]

import { loadSlashCommands, expandCommand, findSlashCommand } from '@nexrall/code-core/commands';
import { loadAgentTypes, findAgentType } from '@nexrall/code-core/agent-types';

// Built-in /review command is always available (overridable)
const cmds = loadSlashCommands(process.cwd());
const review = findSlashCommand(cmds, 'review');
const prompt = expandCommand(review, 'main..feature-branch', process.cwd());

// Built-in 'reviewer' agent (read-only, usable as subagent_type: 'reviewer')
const agents = loadAgentTypes(process.cwd());
const reviewer = findAgentType(agents, 'reviewer');

import { CheckpointManager } from '@nexrall/code-core/checkpoint';

// Scoped per session — persists to ~/.nexrall/checkpoints/<hash>/
const cp = new CheckpointManager(workDir, sessionId);
cp.beginTurn('refactor auth module', messages.length);
// ... agent runs and mutates files ...
cp.commitTurn();

// Roll back files + conversation
const result = cp.restore(cp.list()[0].id);
// result.restored      → absolute paths rolled back
// result.bashCount     → shell commands NOT undone (with warning)
// result.gitStashHashes → git stash create recovery points