415 lines
16 KiB
C#
415 lines
16 KiB
C#
using System.ClientModel;
|
||
using Microsoft.Extensions.AI;
|
||
using OpenAI;
|
||
using AnchorCli;
|
||
using AnchorCli.Tools;
|
||
using AnchorCli.Commands;
|
||
using AnchorCli.OpenRouter;
|
||
using Spectre.Console;
|
||
|
||
// ── Setup subcommand ─────────────────────────────────────────────────────
|
||
if (args.Length > 0 && args[0].Equals("setup", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
SetupTui.Run();
|
||
return;
|
||
}
|
||
|
||
// ── Config ──────────────────────────────────────────────────────────────
|
||
const string endpoint = "https://openrouter.ai/api/v1";
|
||
var cfg = AnchorConfig.Load();
|
||
string apiKey = cfg.ApiKey;
|
||
string model = cfg.Model;
|
||
|
||
if (string.IsNullOrWhiteSpace(apiKey))
|
||
{
|
||
AnsiConsole.MarkupLine("[red]No API key configured. Run [bold]anchor setup[/] first.[/]");
|
||
return;
|
||
}
|
||
|
||
// ── Fetch model pricing from OpenRouter ─────────────────────────────────
|
||
var pricingProvider = new PricingProvider();
|
||
var tokenTracker = new TokenTracker();
|
||
|
||
ModelInfo? modelInfo = null;
|
||
await AnsiConsole.Status()
|
||
.Spinner(Spinner.Known.BouncingBar)
|
||
.SpinnerStyle(Style.Parse("cornflowerblue"))
|
||
.StartAsync("Fetching model pricing...", async ctx =>
|
||
{
|
||
try
|
||
{
|
||
modelInfo = await pricingProvider.GetModelInfoAsync(model);
|
||
if (modelInfo?.Pricing != null)
|
||
{
|
||
tokenTracker.InputPrice = PricingProvider.ParsePrice(modelInfo.Pricing.Prompt);
|
||
tokenTracker.OutputPrice = PricingProvider.ParsePrice(modelInfo.Pricing.Completion);
|
||
tokenTracker.RequestPrice = PricingProvider.ParsePrice(modelInfo.Pricing.Request);
|
||
}
|
||
}
|
||
catch { /* pricing is best-effort */ }
|
||
});
|
||
|
||
// ── Pretty header ───────────────────────────────────────────────────────
|
||
AnsiConsole.Write(
|
||
new FigletText("anchor")
|
||
.Color(Color.CornflowerBlue));
|
||
|
||
AnsiConsole.Write(
|
||
new Rule("[dim]AI-powered coding assistant[/]")
|
||
.RuleStyle(Style.Parse("cornflowerblue dim"))
|
||
.LeftJustified());
|
||
|
||
AnsiConsole.WriteLine();
|
||
|
||
var infoTable = new Table()
|
||
.Border(TableBorder.Rounded)
|
||
.BorderColor(Color.Grey)
|
||
.AddColumn(new TableColumn("[dim]Setting[/]").NoWrap())
|
||
.AddColumn(new TableColumn("[dim]Value[/]"));
|
||
|
||
infoTable.AddRow("[grey]Model[/]", $"[cyan]{Markup.Escape(modelInfo?.Name ?? model)}[/]");
|
||
infoTable.AddRow("[grey]Endpoint[/]", $"[blue]OpenRouter[/]");
|
||
infoTable.AddRow("[grey]CWD[/]", $"[green]{Markup.Escape(Environment.CurrentDirectory)}[/]");
|
||
|
||
if (modelInfo?.Pricing != null)
|
||
{
|
||
var inM = tokenTracker.InputPrice * 1_000_000m;
|
||
var outM = tokenTracker.OutputPrice * 1_000_000m;
|
||
infoTable.AddRow("[grey]Pricing[/]",
|
||
$"[yellow]${inM:F2}[/][dim]/M in[/] [yellow]${outM:F2}[/][dim]/M out[/]");
|
||
}
|
||
if (modelInfo != null)
|
||
{
|
||
infoTable.AddRow("[grey]Context[/]",
|
||
$"[dim]{modelInfo.ContextLength:N0} tokens[/]");
|
||
}
|
||
|
||
AnsiConsole.Write(infoTable);
|
||
AnsiConsole.WriteLine();
|
||
|
||
// ── Build the chat client with tool-calling support ─────────────────────
|
||
var openAiClient = new OpenAIClient(new ApiKeyCredential(apiKey), new OpenAIClientOptions
|
||
{
|
||
Endpoint = new Uri(endpoint)
|
||
});
|
||
|
||
IChatClient innerClient = openAiClient.GetChatClient(model).AsIChatClient();
|
||
|
||
// ── Tool call logging via Spectre ───────────────────────────────────────
|
||
static void ToolLog(string message)
|
||
{
|
||
AnsiConsole.MarkupLine($"[dim grey] ● {Markup.Escape(message)}[/]");
|
||
}
|
||
|
||
CommandTool.Log =
|
||
DirTools.Log =
|
||
FileTools.Log =
|
||
EditTools.Log = ToolLog;
|
||
|
||
// ── Collect all tool methods ────────────────────────────────────────────
|
||
var jsonOptions = AppJsonContext.Default.Options;
|
||
|
||
var tools = new List<AITool>
|
||
{
|
||
AIFunctionFactory.Create(FileTools.ReadFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(FileTools.GrepFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(FileTools.ListDir, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.ReplaceLines, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.InsertAfter, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.DeleteRange, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.CreateFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.DeleteFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.RenameFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.CopyFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(DirTools.CreateDir, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(DirTools.RenameDir, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(DirTools.DeleteDir, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(FileTools.FindFiles, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(FileTools.GrepRecursive, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(FileTools.GetFileInfo, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(EditTools.AppendToFile, serializerOptions: jsonOptions),
|
||
AIFunctionFactory.Create(CommandTool.ExecuteCommand, serializerOptions: jsonOptions),
|
||
};
|
||
|
||
// Wrap with automatic function invocation
|
||
IChatClient agent = new ChatClientBuilder(innerClient)
|
||
.UseFunctionInvocation()
|
||
.Build();
|
||
|
||
// ── Context compactor ──────────────────────────────────────────────────
|
||
var compactor = new ContextCompactor(innerClient);
|
||
|
||
if (modelInfo != null)
|
||
tokenTracker.ContextLength = modelInfo.ContextLength;
|
||
|
||
// ── Chat history with system prompt ─────────────────────────────────────
|
||
List<ChatMessage> history =
|
||
[
|
||
new(ChatRole.System, $$"""
|
||
You are anchor, a coding assistant that edits files using the Hashline technique.
|
||
|
||
## Reading files
|
||
When you read a file, lines are returned in the format: lineNumber:hash|content
|
||
The "lineNumber:hash|" prefix is METADATA for anchoring — it is NOT part of the file.
|
||
|
||
## Editing files
|
||
To edit, reference anchors as "lineNumber:hash" in startAnchor/endAnchor parameters.
|
||
The newLines/initialLines parameter must contain RAW SOURCE CODE ONLY.
|
||
❌ WRONG: ["5:a3| public void Foo()"]
|
||
✅ RIGHT: [" public void Foo()"]
|
||
Never include the "lineNumber:hash|" prefix in content you write — it will corrupt the file.
|
||
|
||
## Workflow
|
||
1. Always read a file before editing it.
|
||
2. After a mutation, verify the returned fingerprint.
|
||
3. Edit from bottom to top so line numbers don't shift.
|
||
4. If an anchor fails validation, re-read the file to get fresh anchors.
|
||
|
||
Keep responses concise. You have access to the current working directory.
|
||
You are running on: {{System.Runtime.InteropServices.RuntimeInformation.OSDescription}}
|
||
""")
|
||
];
|
||
|
||
// ── Command system ─────────────────────────────────────────────────────
|
||
var commandRegistry = new CommandRegistry();
|
||
commandRegistry.Register(new ExitCommand());
|
||
commandRegistry.Register(new HelpCommand(commandRegistry));
|
||
commandRegistry.Register(new ClearCommand());
|
||
commandRegistry.Register(new StatusCommand(model, endpoint));
|
||
commandRegistry.Register(new CompactCommand(compactor, history));
|
||
|
||
var commandDispatcher = new CommandDispatcher(commandRegistry);
|
||
|
||
|
||
// ── REPL ────────────────────────────────────────────────────────────────
|
||
AnsiConsole.MarkupLine("[dim]Type your message, or use [bold]/help[/] to see commands.[/]");
|
||
AnsiConsole.MarkupLine("[dim]Press [bold]Ctrl+C[/] to cancel the current response.[/]");
|
||
AnsiConsole.WriteLine();
|
||
|
||
// Ctrl+C cancellation: cancel the current response, not the process
|
||
CancellationTokenSource? responseCts = null;
|
||
|
||
Console.CancelKeyPress += (_, e) =>
|
||
{
|
||
e.Cancel = true; // Prevent process termination
|
||
responseCts?.Cancel();
|
||
};
|
||
|
||
while (true)
|
||
{
|
||
string input = ReadLine.Read("❯ ");
|
||
|
||
if (string.IsNullOrWhiteSpace(input)) continue;
|
||
|
||
// Try to execute slash command
|
||
if (await commandDispatcher.TryExecuteAsync(input, default)) continue;
|
||
|
||
history.Add(new ChatMessage(ChatRole.User, input));
|
||
|
||
// Track where this turn starts so we can compact previous turns' tool results
|
||
int turnStartIndex = history.Count;
|
||
|
||
AnsiConsole.WriteLine();
|
||
|
||
// Create a fresh CancellationTokenSource for this response
|
||
responseCts = new CancellationTokenSource();
|
||
string fullResponse = "";
|
||
|
||
try
|
||
{
|
||
var options = new ChatOptions { Tools = tools };
|
||
|
||
// Get the async enumerator so we can split into spinner + streaming phases
|
||
await using var stream = agent
|
||
.GetStreamingResponseAsync(history, options, responseCts.Token)
|
||
.GetAsyncEnumerator(responseCts.Token);
|
||
|
||
string? firstChunk = null;
|
||
int respIn = 0, respOut = 0;
|
||
|
||
// Helper: extract usage from a streaming update's raw OpenAI representation
|
||
void CaptureUsage(ChatResponseUpdate update)
|
||
{
|
||
if (update.RawRepresentation is OpenAI.Chat.StreamingChatCompletionUpdate raw
|
||
&& raw.Usage != null)
|
||
{
|
||
respIn += raw.Usage.InputTokenCount;
|
||
respOut += raw.Usage.OutputTokenCount;
|
||
}
|
||
}
|
||
|
||
// Phase 1: Show BouncingBar spinner while agent thinks & invokes tools
|
||
using var spinnerCts = CancellationTokenSource.CreateLinkedTokenSource(responseCts.Token);
|
||
bool showSpinner = true;
|
||
|
||
CommandTool.PauseSpinner = () =>
|
||
{
|
||
showSpinner = false;
|
||
Console.Write("\r" + new string(' ', 40) + "\r");
|
||
};
|
||
CommandTool.ResumeSpinner = () =>
|
||
{
|
||
showSpinner = true;
|
||
};
|
||
|
||
var spinnerTask = Task.Run(async () =>
|
||
{
|
||
var frames = Spinner.Known.BouncingBar.Frames;
|
||
var interval = Spinner.Known.BouncingBar.Interval;
|
||
int i = 0;
|
||
|
||
// Hide cursor
|
||
Console.Write("\x1b[?25l");
|
||
try
|
||
{
|
||
while (!spinnerCts.Token.IsCancellationRequested)
|
||
{
|
||
if (showSpinner)
|
||
{
|
||
var frame = frames[i % frames.Count];
|
||
Console.Write($"\r\x1b[38;5;69m{frame}\x1b[0m Thinking...");
|
||
i++;
|
||
}
|
||
try { await Task.Delay(interval, spinnerCts.Token); } catch { }
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
// Clear the spinner line and show cursor
|
||
if (showSpinner)
|
||
Console.Write("\r" + new string(' ', 40) + "\r");
|
||
Console.Write("\x1b[?25h");
|
||
}
|
||
});
|
||
|
||
try
|
||
{
|
||
while (await stream.MoveNextAsync())
|
||
{
|
||
responseCts.Token.ThrowIfCancellationRequested();
|
||
CaptureUsage(stream.Current);
|
||
if (!string.IsNullOrEmpty(stream.Current.Text))
|
||
{
|
||
firstChunk = stream.Current.Text;
|
||
fullResponse = firstChunk;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
spinnerCts.Cancel();
|
||
await Task.WhenAny(spinnerTask);
|
||
CommandTool.PauseSpinner = null;
|
||
CommandTool.ResumeSpinner = null;
|
||
}
|
||
|
||
// Phase 2: Stream text tokens directly to the console
|
||
if (firstChunk != null)
|
||
{
|
||
AnsiConsole.Markup(Markup.Escape(firstChunk));
|
||
}
|
||
|
||
while (await stream.MoveNextAsync())
|
||
{
|
||
responseCts.Token.ThrowIfCancellationRequested();
|
||
CaptureUsage(stream.Current);
|
||
var text = stream.Current.Text;
|
||
if (!string.IsNullOrEmpty(text))
|
||
{
|
||
AnsiConsole.Markup(Markup.Escape(text));
|
||
}
|
||
fullResponse += text;
|
||
}
|
||
|
||
// Record usage and display cost
|
||
if (respIn > 0 || respOut > 0)
|
||
{
|
||
tokenTracker.AddUsage(respIn, respOut);
|
||
var cost = tokenTracker.CalculateCost(respIn, respOut);
|
||
var ctxPct = tokenTracker.ContextUsagePercent;
|
||
AnsiConsole.WriteLine();
|
||
AnsiConsole.MarkupLine(
|
||
$"[dim grey] {TokenTracker.FormatTokens(respIn)}↑ {TokenTracker.FormatTokens(respOut)}↓" +
|
||
$" {TokenTracker.FormatCost(cost)}" +
|
||
(ctxPct >= 0 ? $" ctx:{ctxPct:F0}%" : "") +
|
||
$" │ session: {TokenTracker.FormatCost(tokenTracker.SessionCost)}[/]");
|
||
}
|
||
else
|
||
{
|
||
AnsiConsole.WriteLine();
|
||
}
|
||
|
||
AnsiConsole.Write(new Rule().RuleStyle(Style.Parse("grey dim")));
|
||
AnsiConsole.WriteLine();
|
||
|
||
history.Add(new ChatMessage(ChatRole.Assistant, fullResponse));
|
||
|
||
// ── Compact stale ReadFile/Grep results from previous turns ─
|
||
int compactedResults = ContextCompactor.CompactStaleToolResults(history, turnStartIndex);
|
||
if (compactedResults > 0)
|
||
{
|
||
AnsiConsole.MarkupLine(
|
||
$"[dim grey] ♻ Compacted {compactedResults} stale tool result(s) from previous turns[/]");
|
||
}
|
||
|
||
// ── Auto-compact context if approaching the limit ───────────
|
||
if (tokenTracker.ShouldCompact())
|
||
{
|
||
var pct = tokenTracker.ContextUsagePercent;
|
||
AnsiConsole.MarkupLine(
|
||
$"[yellow]⚠ Context at {pct:F0}% — compacting conversation history...[/]");
|
||
|
||
bool compacted = await AnsiConsole.Status()
|
||
.Spinner(Spinner.Known.BouncingBar)
|
||
.SpinnerStyle(Style.Parse("yellow"))
|
||
.StartAsync("Compacting context...", async ctx =>
|
||
await compactor.TryCompactAsync(history, default));
|
||
|
||
if (compacted)
|
||
{
|
||
AnsiConsole.MarkupLine(
|
||
$"[green]✓ Context compacted ({history.Count} messages remaining)[/]");
|
||
}
|
||
else
|
||
{
|
||
AnsiConsole.MarkupLine(
|
||
"[dim grey] (compaction skipped — not enough history to compress)[/]");
|
||
}
|
||
AnsiConsole.WriteLine();
|
||
}
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
// Keep partial response in history so the agent has context
|
||
AnsiConsole.WriteLine();
|
||
AnsiConsole.MarkupLine("[dim grey] ✗ Cancelled[/]");
|
||
AnsiConsole.Write(new Rule().RuleStyle(Style.Parse("grey dim")));
|
||
AnsiConsole.WriteLine();
|
||
|
||
if (!string.IsNullOrEmpty(fullResponse))
|
||
{
|
||
history.Add(new ChatMessage(ChatRole.Assistant, fullResponse));
|
||
}
|
||
history.Add(new ChatMessage(ChatRole.User,
|
||
"[Response cancelled by user. Acknowledge briefly and wait for the next instruction. Do not repeat what was already said.]"));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AnsiConsole.WriteLine();
|
||
AnsiConsole.Write(
|
||
new Panel($"[red]{Markup.Escape(ex.Message)}[/]")
|
||
.Header("[bold red] Error [/]")
|
||
.BorderColor(Color.Red)
|
||
.RoundedBorder()
|
||
.Padding(1, 0));
|
||
AnsiConsole.WriteLine();
|
||
}
|
||
finally
|
||
{
|
||
responseCts?.Dispose();
|
||
responseCts = null;
|
||
}
|
||
}
|
||
|