@nghyane/arcane 0.1.13 → 0.1.14

package/src/session/streaming-edit.ts

@@ -0,0 +1,258 @@
+import * as fs from "node:fs";
+
+import type { Agent, AgentEvent } from "@nghyane/arcane-agent";
+import type { AssistantMessage, ToolCall } from "@nghyane/arcane-ai";
+import { isEnoent, logger } from "@nghyane/arcane-utils";
+import type { Settings } from "../config/settings";
+import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../patch";
+import type { SecretObfuscator } from "../secrets/obfuscator";
+import { resolveToCwd } from "../tools/path-utils";
+import type { SessionManager } from "./session-manager";
+
+/**
+ * Mutable state for streaming edit abort detection.
+ */
+export interface StreamingEditState {
+	abortTriggered: boolean;
+	checkedLineCounts: Map<string, number>;
+	fileCache: Map<string, string>;
+}
+
+export function createStreamingEditState(): StreamingEditState {
+	return {
+		abortTriggered: false,
+		checkedLineCounts: new Map(),
+		fileCache: new Map(),
+	};
+}
+
+export function resetStreamingEditState(state: StreamingEditState): void {
+	state.abortTriggered = false;
+	state.checkedLineCounts.clear();
+	state.fileCache.clear();
+}
+
+export async function preCacheStreamingEditFile(
+	event: AgentEvent,
+	state: StreamingEditState,
+	settings: Settings,
+	cwd: string,
+): Promise<void> {
+	if (!settings.get("edit.streamingAbort")) return;
+	if (event.type !== "message_update") return;
+	const assistantEvent = event.assistantMessageEvent;
+	if (assistantEvent.type !== "toolcall_start") return;
+	if (event.message.role !== "assistant") return;
+
+	const contentIndex = assistantEvent.contentIndex;
+	const messageContent = event.message.content;
+	if (!Array.isArray(messageContent) || contentIndex >= messageContent.length) return;
+	const toolCall = messageContent[contentIndex] as ToolCall;
+	if (toolCall.name !== "edit") return;
+
+	const args = toolCall.arguments;
+	if (!args || typeof args !== "object" || Array.isArray(args)) return;
+	if ("old_text" in args || "new_text" in args) return;
+
+	const path = typeof args.path === "string" ? args.path : undefined;
+	if (!path) return;
+
+	const resolvedPath = resolveToCwd(path, cwd);
+	ensureFileCache(state, resolvedPath);
+}
+
+export function ensureFileCache(state: StreamingEditState, resolvedPath: string): void {
+	if (state.fileCache.has(resolvedPath)) return;
+
+	try {
+		const rawText = fs.readFileSync(resolvedPath, "utf-8");
+		const { text } = stripBom(rawText);
+		state.fileCache.set(resolvedPath, normalizeToLF(text));
+	} catch {
+		// Don't cache on read errors (including ENOENT) - let the edit tool handle them
+	}
+}
+
+export function invalidateFileCacheForPath(state: StreamingEditState, path: string, cwd: string): void {
+	const resolvedPath = resolveToCwd(path, cwd);
+	state.fileCache.delete(resolvedPath);
+}
+
+export function maybeAbortStreamingEdit(
+	event: AgentEvent,
+	state: StreamingEditState,
+	settings: Settings,
+	agent: Agent,
+	cwd: string,
+	obfuscator: SecretObfuscator | undefined,
+): void {
+	if (!settings.get("edit.streamingAbort")) return;
+	if (state.abortTriggered) return;
+	if (event.type !== "message_update") return;
+	const assistantEvent = event.assistantMessageEvent;
+	if (assistantEvent.type !== "toolcall_end" && assistantEvent.type !== "toolcall_delta") return;
+	if (event.message.role !== "assistant") return;
+
+	const contentIndex = assistantEvent.contentIndex;
+	const messageContent = event.message.content;
+	if (!Array.isArray(messageContent) || contentIndex >= messageContent.length) return;
+	const toolCall = messageContent[contentIndex] as ToolCall;
+	if (toolCall.name !== "edit" || !toolCall.id) return;
+
+	const args = toolCall.arguments;
+	if (!args || typeof args !== "object" || Array.isArray(args)) return;
+	if ("old_text" in args || "new_text" in args) return;
+
+	const path = typeof args.path === "string" ? args.path : undefined;
+	const diff = typeof args.diff === "string" ? args.diff : undefined;
+	const op = typeof args.op === "string" ? args.op : undefined;
+	if (!path || !diff) return;
+	if (op && op !== "update") return;
+
+	if (!diff.includes("\n")) return;
+	const lastNewlineIndex = diff.lastIndexOf("\n");
+	if (lastNewlineIndex < 0) return;
+	const diffForCheck = diff.endsWith("\n") ? diff : diff.slice(0, lastNewlineIndex + 1);
+	if (diffForCheck.trim().length === 0) return;
+
+	let normalizedDiffResult = normalizeDiff(diffForCheck.replace(/\r/g, ""));
+	if (!normalizedDiffResult) return;
+	if (obfuscator) normalizedDiffResult = obfuscator.deobfuscate(normalizedDiffResult);
+	if (!normalizedDiffResult) return;
+	const lines = normalizedDiffResult.split("\n");
+	const hasChangeLine = lines.some(line => line.startsWith("+") || line.startsWith("-"));
+	if (!hasChangeLine) return;
+
+	const lineCount = lines.length;
+	const lastChecked = state.checkedLineCounts.get(toolCall.id);
+	if (lastChecked !== undefined && lineCount <= lastChecked) return;
+	state.checkedLineCounts.set(toolCall.id, lineCount);
+
+	const rename = typeof args.rename === "string" ? args.rename : undefined;
+
+	const removedLines = lines
+		.filter(line => line.startsWith("-") && !line.startsWith("--- "))
+		.map(line => line.slice(1));
+	if (removedLines.length > 0) {
+		const resolvedPath = resolveToCwd(path, cwd);
+		let cachedContent = state.fileCache.get(resolvedPath);
+		if (cachedContent === undefined) {
+			ensureFileCache(state, resolvedPath);
+			cachedContent = state.fileCache.get(resolvedPath);
+		}
+		if (cachedContent !== undefined) {
+			const missing = removedLines.find(line => !cachedContent.includes(normalizeToLF(line)));
+			if (missing) {
+				state.abortTriggered = true;
+				logger.warn("Streaming edit aborted due to patch preview failure", {
+					toolCallId: toolCall.id,
+					path,
+					error: `Failed to find expected lines in ${path}:\n${missing}`,
+				});
+				agent.abort();
+			}
+			return;
+		}
+		if (assistantEvent.type === "toolcall_delta") return;
+		void checkRemovedLinesAsync(state, agent, toolCall.id, path, resolvedPath, removedLines);
+		return;
+	}
+
+	if (assistantEvent.type === "toolcall_delta") return;
+	void checkPreviewPatchAsync(state, agent, settings, cwd, toolCall.id, path, rename, normalizedDiffResult);
+}
+
+async function checkRemovedLinesAsync(
+	state: StreamingEditState,
+	agent: Agent,
+	toolCallId: string,
+	path: string,
+	resolvedPath: string,
+	removedLines: string[],
+): Promise<void> {
+	if (state.abortTriggered) return;
+	try {
+		const { text } = stripBom(await Bun.file(resolvedPath).text());
+		const normalizedContent = normalizeToLF(text);
+		const missing = removedLines.find(line => !normalizedContent.includes(normalizeToLF(line)));
+		if (missing) {
+			state.abortTriggered = true;
+			logger.warn("Streaming edit aborted due to patch preview failure", {
+				toolCallId,
+				path,
+				error: `Failed to find expected lines in ${path}:\n${missing}`,
+			});
+			agent.abort();
+		}
+	} catch (err) {
+		if (!isEnoent(err)) {
+			// Log unexpected errors but don't abort
+		}
+	}
+}
+
+async function checkPreviewPatchAsync(
+	state: StreamingEditState,
+	agent: Agent,
+	settings: Settings,
+	cwd: string,
+	toolCallId: string,
+	path: string,
+	rename: string | undefined,
+	normalizedDiff: string,
+): Promise<void> {
+	if (state.abortTriggered) return;
+	try {
+		await previewPatch(
+			{ path, op: "update", rename, diff: normalizedDiff },
+			{
+				cwd,
+				allowFuzzy: settings.get("edit.fuzzyMatch"),
+				fuzzyThreshold: settings.get("edit.fuzzyThreshold"),
+			},
+		);
+	} catch (error) {
+		if (error instanceof ParseError) return;
+		state.abortTriggered = true;
+		logger.warn("Streaming edit aborted due to patch preview failure", {
+			toolCallId,
+			path,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		agent.abort();
+	}
+}
+
+/**
+ * Rewrite tool call arguments in agent state and persisted session history.
+ */
+export async function rewriteToolCallArgs(
+	agent: Agent,
+	sessionManager: SessionManager,
+	toolCallId: string,
+	args: Record<string, unknown>,
+): Promise<void> {
+	let updated = false;
+	const messages = agent.state.messages;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role !== "assistant") continue;
+		const assistantMsg = msg as AssistantMessage;
+		if (!Array.isArray(assistantMsg.content)) continue;
+		for (const block of assistantMsg.content) {
+			if (typeof block !== "object" || block === null) continue;
+			if (!("type" in block) || (block as { type?: string }).type !== "toolCall") continue;
+			const toolCall = block as { id?: string; arguments?: Record<string, unknown> };
+			if (toolCall.id === toolCallId) {
+				toolCall.arguments = args;
+				updated = true;
+				break;
+			}
+		}
+		if (updated) break;
+	}
+
+	if (updated) {
+		await sessionManager.rewriteAssistantToolCallArgs(toolCallId, args);
+	}
+}

package/src/session/ttsr.ts

@@ -0,0 +1,213 @@
+import * as path from "node:path";
+
+import type { Agent, AgentMessage } from "@nghyane/arcane-agent";
+import type { AssistantMessage, ToolCall } from "@nghyane/arcane-ai";
+import type { Rule } from "../capability/rule";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { TtsrManager, TtsrMatchContext } from "../export/ttsr";
+import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
+import type { SessionManager } from "./session-manager";
+
+/**
+ * Mutable state for TTSR (time-traveling stream rules).
+ */
+export interface TtsrState {
+	pendingInjections: Rule[];
+	abortPending: boolean;
+	retryToken: number;
+}
+
+export function createTtsrState(): TtsrState {
+	return {
+		pendingInjections: [],
+		abortPending: false,
+		retryToken: 0,
+	};
+}
+
+/** Get TTSR injection payload and clear pending injections. */
+export function getTtsrInjectionContent(state: TtsrState): { content: string; rules: Rule[] } | undefined {
+	if (state.pendingInjections.length === 0) return undefined;
+	const rules = state.pendingInjections;
+	const content = rules
+		.map(r => renderPromptTemplate(ttsrInterruptTemplate, { name: r.name, path: r.path, content: r.content }))
+		.join("\n\n");
+	state.pendingInjections = [];
+	return { content, rules };
+}
+
+export function addPendingTtsrInjections(state: TtsrState, rules: Rule[]): void {
+	const seen = new Set(state.pendingInjections.map(rule => rule.name));
+	for (const rule of rules) {
+		if (seen.has(rule.name)) continue;
+		state.pendingInjections.push(rule);
+		seen.add(rule.name);
+	}
+}
+
+export function extractTtsrRuleNames(details: unknown): string[] {
+	if (!details || typeof details !== "object" || Array.isArray(details)) {
+		return [];
+	}
+	const rules = (details as { rules?: unknown }).rules;
+	if (!Array.isArray(rules)) {
+		return [];
+	}
+	return rules.filter((ruleName): ruleName is string => typeof ruleName === "string");
+}
+
+export function markTtsrInjected(
+	ttsrManager: TtsrManager | undefined,
+	sessionManager: SessionManager,
+	ruleNames: string[],
+): void {
+	const uniqueRuleNames = Array.from(
+		new Set(ruleNames.map(ruleName => ruleName.trim()).filter(ruleName => ruleName.length > 0)),
+	);
+	if (uniqueRuleNames.length === 0) {
+		return;
+	}
+	ttsrManager?.markInjectedByNames(uniqueRuleNames);
+	sessionManager.appendTtsrInjection(uniqueRuleNames);
+}
+
+export function findTtsrAssistantIndex(messages: AgentMessage[], targetTimestamp: number | undefined): number {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role !== "assistant") {
+			continue;
+		}
+		if (targetTimestamp === undefined || message.timestamp === targetTimestamp) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+export function shouldInterruptForTtsrMatch(
+	ttsrManager: TtsrManager | undefined,
+	matchContext: TtsrMatchContext,
+): boolean {
+	const mode = ttsrManager?.getSettings().interruptMode ?? "always";
+	if (mode === "never") {
+		return false;
+	}
+	if (mode === "prose-only") {
+		return matchContext.source === "text" || matchContext.source === "thinking";
+	}
+	if (mode === "tool-only") {
+		return matchContext.source === "tool";
+	}
+	return true;
+}
+
+export function queueDeferredTtsrInjectionIfNeeded(
+	state: TtsrState,
+	agent: Agent,
+	assistantMsg: AssistantMessage,
+): void {
+	if (state.abortPending || state.pendingInjections.length === 0) {
+		return;
+	}
+	if (assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error") {
+		state.pendingInjections = [];
+		return;
+	}
+
+	const injection = getTtsrInjectionContent(state);
+	if (!injection) {
+		return;
+	}
+	agent.followUp({
+		role: "custom",
+		customType: "ttsr-injection",
+		content: injection.content,
+		display: false,
+		details: { rules: injection.rules.map(rule => rule.name) },
+		timestamp: Date.now(),
+	});
+	setTimeout(() => {
+		if (agent.state.isStreaming || !agent.hasQueuedMessages()) {
+			return;
+		}
+		agent.continue().catch(() => {});
+	}, 0);
+}
+
+/** Build TTSR match context for tool call argument deltas. */
+export function getTtsrToolMatchContext(message: AgentMessage, contentIndex: number, cwd: string): TtsrMatchContext {
+	const context: TtsrMatchContext = { source: "tool" };
+	if (message.role !== "assistant") {
+		return context;
+	}
+
+	const content = message.content;
+	if (!Array.isArray(content) || contentIndex < 0 || contentIndex >= content.length) {
+		return context;
+	}
+
+	const block = content[contentIndex];
+	if (!block || typeof block !== "object" || block.type !== "toolCall") {
+		return context;
+	}
+
+	const toolCall = block as ToolCall;
+	context.toolName = toolCall.name;
+	context.streamKey = toolCall.id ? `toolcall:${toolCall.id}` : `tool:${toolCall.name}:${contentIndex}`;
+	context.filePaths = extractTtsrFilePathsFromArgs(toolCall.arguments, cwd);
+	return context;
+}
+
+/** Extract path-like arguments from tool call payload for TTSR glob matching. */
+export function extractTtsrFilePathsFromArgs(args: unknown, cwd: string): string[] | undefined {
+	if (!args || typeof args !== "object" || Array.isArray(args)) {
+		return undefined;
+	}
+
+	const rawPaths: string[] = [];
+	for (const [key, value] of Object.entries(args)) {
+		const normalizedKey = key.toLowerCase();
+		if (typeof value === "string" && (normalizedKey === "path" || normalizedKey.endsWith("path"))) {
+			rawPaths.push(value);
+			continue;
+		}
+		if (Array.isArray(value) && (normalizedKey === "paths" || normalizedKey.endsWith("paths"))) {
+			for (const candidate of value) {
+				if (typeof candidate === "string") {
+					rawPaths.push(candidate);
+				}
+			}
+		}
+	}
+
+	const normalizedPaths = rawPaths.flatMap(pathValue => normalizeTtsrPathCandidates(pathValue, cwd));
+	if (normalizedPaths.length === 0) {
+		return undefined;
+	}
+
+	return Array.from(new Set(normalizedPaths));
+}
+
+/** Convert a path argument into stable relative/absolute candidates for glob checks. */
+export function normalizeTtsrPathCandidates(rawPath: string, cwd: string): string[] {
+	const trimmed = rawPath.trim();
+	if (trimmed.length === 0) {
+		return [];
+	}
+
+	const normalizedInput = trimmed.replaceAll("\\", "/");
+	const candidates = new Set<string>([normalizedInput]);
+	if (normalizedInput.startsWith("./")) {
+		candidates.add(normalizedInput.slice(2));
+	}
+
+	const absolutePath = path.isAbsolute(trimmed) ? path.normalize(trimmed) : path.resolve(cwd, trimmed);
+	candidates.add(absolutePath.replaceAll("\\", "/"));
+
+	const relativePath = path.relative(cwd, absolutePath).replaceAll("\\", "/");
+	if (relativePath && relativePath !== "." && !relativePath.startsWith("../") && relativePath !== "..") {
+		candidates.add(relativePath);
+	}
+
+	return Array.from(candidates);
+}

package/src/slash-commands/builtin-registry.ts

@@ -204,14 +204,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
-	{
-		name: "agents",
-		description: "Open Agent Control Center dashboard",
-		handle: (_command, runtime) => {
-			runtime.ctx.showAgentsDashboard();
-			runtime.ctx.editor.setText("");
-		},
-	},
 	{
 		name: "branch",
 		description: "Create a new branch from a previous message",

package/src/stt/recorder.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { logger, Snowflake } from "@nghyane/arcane-utils";
-import { $ } from "bun";
+import { $, type Subprocess } from "bun";
 
 export interface RecordingHandle {
 	stop(): Promise<void>;
@@ -277,7 +277,7 @@ async function startPowerShellRecording(outputPath: string): Promise<RecordingHa
 
 // ── Health check ───────────────────────────────────────────────────
 
-async function verifyProcessAlive(proc: ReturnType<typeof Bun.spawn>, tool: string): Promise<void> {
+async function verifyProcessAlive(proc: Subprocess, tool: string): Promise<void> {
 	await Bun.sleep(300);
 
 	const exited = await Promise.race([proc.exited.then(code => code), Bun.sleep(0).then(() => "running" as const)]);

package/src/system-prompt.ts

@@ -334,9 +334,7 @@ function getSystemInfoCachePath(): string {
 async function loadGpuCache(): Promise<GpuCache | null> {
 	try {
 		const cachePath = getSystemInfoCachePath();
-		const file = Bun.file(cachePath);
-		if (!(await file.exists())) return null;
-		const content = await file.json();
+		const content = await Bun.file(cachePath).json();
 		return content as GpuCache;
 	} catch {
 		return null;
@@ -470,8 +468,6 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
-	/** Repeat full tool descriptions in system prompt. Default: false */
-	repeatToolDescriptions?: boolean;
 	/** Skills settings for discovery. */
 	skillsSettings?: SkillsSettings;
 	/** Working directory. Default: getProjectDir() */
@@ -496,7 +492,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
-		repeatToolDescriptions = false,
 		skillsSettings,
 		toolNames,
 		cwd,
@@ -636,12 +631,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		toolNamesArray = defaultToolNames;
 	}
 
-	// Build tool descriptions for system prompt rendering
-	const toolDescriptions = toolNamesArray.map(name => ({
-		name,
-		description: tools?.get(name)?.description ?? "",
-	}));
-
 	// Filter skills to only include those with read tool
 	const hasRead = tools?.has("read");
 	const filteredSkills = preloadedSkills === undefined && hasRead ? skills : [];
@@ -667,8 +656,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	time("getEnvironmentInfo");
 	return renderPromptTemplate(systemPromptTemplate, {
 		tools: toolNamesArray,
-		toolDescriptions,
-		repeatToolDescriptions,
 		environment,
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,

package/src/task/agents.ts

@@ -7,55 +7,28 @@ import { renderPromptTemplate } from "../config/prompt-templates";
 import { parseAgentFields } from "../discovery/helpers";
 import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
-import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
+import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
+import oracleMd from "../prompts/agents/oracle.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
 import taskMd from "../prompts/agents/task.md" with { type: "text" };
 import { parseFrontmatter } from "../utils/frontmatter";
 import type { AgentDefinition, AgentSource } from "./types";
 
-interface AgentFrontmatter {
-	name: string;
-	description: string;
-	tools?: string[];
-	model?: string | string[];
-	thinkingLevel?: string;
-}
-
 interface EmbeddedAgentDef {
 	fileName: string;
-	frontmatter?: AgentFrontmatter;
 	template: string;
 }
 
 function buildAgentContent(def: EmbeddedAgentDef): string {
-	const body = renderPromptTemplate(def.template);
-	if (!def.frontmatter) return body;
-	return renderPromptTemplate(agentFrontmatterTemplate, { ...def.frontmatter, body });
+	return renderPromptTemplate(def.template);
 }
 
 const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "explore.md", template: exploreMd },
+	{ fileName: "librarian.md", template: librarianMd },
+	{ fileName: "oracle.md", template: oracleMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
-	{
-		fileName: "task.md",
-		frontmatter: {
-			name: "task",
-			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
-			model: "default",
-			thinkingLevel: "medium",
-		},
-		template: taskMd,
-	},
-	{
-		fileName: "quick_task.md",
-		frontmatter: {
-			name: "quick_task",
-			description: "Low-reasoning agent for strictly mechanical updates or data collection only",
-			model: "arcane/fast",
-			thinkingLevel: "minimal",
-		},
-		template: taskMd,
-	},
+	{ fileName: "task.md", template: taskMd },
 ];
 
 const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map(def => ({
@@ -105,6 +78,7 @@ export function parseAgent(
 	}
 	return {
 		...fields,
+		kind: fields.kind ?? "hybrid",
 		systemPrompt: body,
 		source,
 		filePath,