@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/completion/tool-bridge.ts

@@ -0,0 +1,55 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { EvalKernel } from "../tool/types.ts";
+import type { CompletionRequest, CompletionResult } from "./handler.ts";
+
+export interface CompletionToolCallOptions {
+	readonly message: Extract<KernelToHostMessage, { type: "tool-call" }>;
+	readonly kernel: EvalKernel;
+	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	readonly ctx: ExtensionContext;
+	readonly isActive: () => boolean;
+}
+
+export type CompletionToolCallSummary = { readonly ok: true } | { readonly ok: false; readonly error: string };
+
+export async function handleCompletionToolCall(options: CompletionToolCallOptions): Promise<CompletionToolCallSummary> {
+	try {
+		const result = await options.complete(toCompletionRequest(options.message.args), options.ctx);
+		if (!options.isActive()) return { ok: false, error: "completion() result ignored after eval finalization" };
+		options.kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: options.message.callId,
+			ok: true,
+			value: completionReplyValue(result),
+		});
+		return { ok: true };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (!options.isActive()) return { ok: false, error: message };
+		options.kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: options.message.callId,
+			ok: false,
+			error: { message },
+		});
+		return { ok: false, error: message };
+	}
+}
+
+function toCompletionRequest(value: unknown): CompletionRequest {
+	if (typeof value === "object" && value !== null && "prompt" in value && typeof value.prompt === "string") {
+		return {
+			prompt: value.prompt,
+			opts: "opts" in value ? value.opts : undefined,
+			model: "model" in value && typeof value.model === "string" ? value.model : undefined,
+			system: "system" in value && typeof value.system === "string" ? value.system : undefined,
+			schema: "schema" in value ? value.schema : undefined,
+		};
+	}
+	throw new Error("completion() received invalid arguments");
+}
+
+function completionReplyValue(result: CompletionResult): unknown {
+	return "value" in result ? result.value : result.text;
+}

package/src/config/settings.ts

@@ -0,0 +1,215 @@
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+
+export const codemodeSettingsSchema = Type.Object(
+	{
+		languages: Type.Optional(
+			Type.Object(
+				{
+					py: Type.Optional(Type.Boolean()),
+					js: Type.Optional(Type.Boolean()),
+					rb: Type.Optional(Type.Boolean()),
+					jl: Type.Optional(Type.Boolean()),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
+		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
+		taskTools: Type.Optional(
+			Type.Object(
+				{
+					task: Type.Optional(Type.String()),
+					output: Type.Optional(Type.String()),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		outputSink: Type.Optional(
+			Type.Object(
+				{
+					headBytes: Type.Optional(Type.Number({ minimum: 0 })),
+					maxColumns: Type.Optional(Type.Number({ minimum: 0 })),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		statusEvents: Type.Optional(Type.Boolean()),
+	},
+	{ additionalProperties: false },
+);
+
+export type CodemodeSettingsInput = Static<typeof codemodeSettingsSchema>;
+
+export interface CodemodeTaskTools {
+	readonly task: string;
+	readonly output: string;
+}
+
+export interface CodemodeOutputSink {
+	readonly headBytes: number;
+	readonly maxColumns: number;
+}
+
+export interface CodemodeSettings {
+	readonly languages: {
+		readonly py: boolean;
+		readonly js: boolean;
+		readonly rb: boolean;
+		readonly jl: boolean;
+	};
+	readonly cellTimeoutSeconds: number;
+	readonly parallelPoolWidth: number;
+	readonly taskTools?: CodemodeTaskTools;
+	readonly outputSink?: CodemodeOutputSink;
+	readonly statusEvents?: boolean;
+}
+
+export type ResolvedCodemodeSettings = CodemodeSettings & {
+	readonly taskTools: CodemodeTaskTools;
+	readonly outputSink: CodemodeOutputSink;
+	readonly statusEvents: boolean;
+};
+
+export interface LoadCodemodeSettingsOptions {
+	readonly cwd?: string;
+	readonly homeDir?: string;
+}
+
+export interface LoadedCodemodeSettings {
+	readonly settings: ResolvedCodemodeSettings;
+	readonly source: string | null;
+	readonly warnings: readonly string[];
+}
+
+// OMP settings-schema.ts:3211-3299 has language/path settings only; eval.ts:427
+// defaults timeout to 30s, and codemode pins concurrency-bridge.ts:30 width to 4.
+export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
+	languages: {
+		py: true,
+		js: true,
+		rb: false,
+		jl: false,
+	},
+	cellTimeoutSeconds: 30,
+	parallelPoolWidth: 4,
+	taskTools: {
+		task: "task",
+		output: "task_output",
+	},
+	outputSink: {
+		headBytes: 20_480,
+		maxColumns: 768,
+	},
+	statusEvents: true,
+};
+
+const languageEnvironmentFlags = {
+	py: "SENPI_CODEMODE_PY",
+	js: "SENPI_CODEMODE_JS",
+	rb: "SENPI_CODEMODE_RB",
+	jl: "SENPI_CODEMODE_JL",
+} as const;
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
+export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions = {}): Promise<LoadedCodemodeSettings> {
+	const cwd = options.cwd ?? process.cwd();
+	const homeDir = options.homeDir ?? homedir();
+	const candidates = [join(cwd, ".senpi", "codemode.json"), join(homeDir, ".senpi", "agent", "codemode.json")];
+
+	for (const candidate of candidates) {
+		if (!(await fileExists(candidate))) {
+			continue;
+		}
+		return loadSettingsFile(candidate);
+	}
+
+	return { settings: defaultCodemodeSettings, source: null, warnings: [] };
+}
+
+export function resolveEnabledLanguages(
+	settings: CodemodeSettings,
+	env: Environment = process.env,
+): CodemodeSettings["languages"] {
+	return {
+		py: resolveLanguage(settings.languages.py, env[languageEnvironmentFlags.py]),
+		js: resolveLanguage(settings.languages.js, env[languageEnvironmentFlags.js]),
+		rb: resolveLanguage(settings.languages.rb, env[languageEnvironmentFlags.rb]),
+		jl: resolveLanguage(settings.languages.jl, env[languageEnvironmentFlags.jl]),
+	};
+}
+
+async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
+	const raw = await readFile(path, "utf8");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			settings: defaultCodemodeSettings,
+			source: path,
+			warnings: [`Invalid JSON in ${path}: ${message}. Falling back to codemode defaults.`],
+		};
+	}
+
+	if (!Check(codemodeSettingsSchema, parsed)) {
+		return {
+			settings: defaultCodemodeSettings,
+			source: path,
+			warnings: [`Invalid codemode settings in ${path}. Falling back to codemode defaults.`],
+		};
+	}
+
+	return { settings: mergeSettings(parsed), source: path, warnings: [] };
+}
+
+function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
+	return {
+		languages: {
+			py: input.languages?.py ?? defaultCodemodeSettings.languages.py,
+			js: input.languages?.js ?? defaultCodemodeSettings.languages.js,
+			rb: input.languages?.rb ?? defaultCodemodeSettings.languages.rb,
+			jl: input.languages?.jl ?? defaultCodemodeSettings.languages.jl,
+		},
+		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
+		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
+		taskTools: {
+			task: input.taskTools?.task ?? defaultCodemodeSettings.taskTools.task,
+			output: input.taskTools?.output ?? defaultCodemodeSettings.taskTools.output,
+		},
+		outputSink: {
+			headBytes: input.outputSink?.headBytes ?? defaultCodemodeSettings.outputSink.headBytes,
+			maxColumns: input.outputSink?.maxColumns ?? defaultCodemodeSettings.outputSink.maxColumns,
+		},
+		statusEvents: input.statusEvents ?? defaultCodemodeSettings.statusEvents,
+	};
+}
+
+function resolveLanguage(fileSetting: boolean, environmentValue: string | undefined): boolean {
+	if (environmentValue === undefined) return fileSetting;
+	switch (environmentValue.trim().toLowerCase()) {
+		case "0":
+		case "false":
+			return false;
+		case "1":
+		case "true":
+			return true;
+		default:
+			return fileSetting;
+	}
+}
+
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/extension/runtime-factory.ts

@@ -0,0 +1,114 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import {
+	type CodemodeSettings,
+	loadCodemodeSettings,
+	type ResolvedCodemodeSettings,
+	resolveEnabledLanguages,
+} from "../config/settings.ts";
+import {
+	createInterpreterDetector,
+	getInterpreterAvailability,
+	type InterpreterAvailability,
+} from "../interpreters/detect.ts";
+import { resolveSessionArtifactsDir } from "../output/streaming-output.ts";
+import type { EnabledEvalLanguages, EvalLanguage } from "../tool/types.ts";
+import {
+	type CodemodeSessionManager,
+	type CreateCodemodeSessionManagerOptions,
+	createCodemodeSessionManager,
+} from "./session-manager.ts";
+
+export interface CodemodeRuntimeAPI {
+	readonly executeTool: AgentExecuteTool;
+	getActiveTools(): string[];
+}
+
+export interface RuntimeFactoryOptions {
+	readonly createSessionManager?: (
+		options: CreateCodemodeSessionManagerOptions,
+	) => CodemodeSessionManager | Promise<CodemodeSessionManager>;
+}
+
+export type SessionRuntime = {
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly parallelPoolWidth: number;
+	readonly manager: CodemodeSessionManager;
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly settings: ResolvedCodemodeSettings;
+	readonly artifactsDir: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly spawns: boolean;
+};
+
+export async function createRuntime(
+	pi: CodemodeRuntimeAPI,
+	ctx: ExtensionContext,
+	event: unknown,
+	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
+	options: RuntimeFactoryOptions,
+): Promise<SessionRuntime> {
+	const loaded = await loadCodemodeSettings({ cwd: ctx.cwd });
+	const settings: ResolvedCodemodeSettings = {
+		...loaded.settings,
+		languages: resolveEnabledLanguages(loaded.settings),
+	};
+	const availability = await getInterpreterAvailability(settings, createInterpreterDetector());
+	const enabledLanguages = enabledLanguagesFrom(settings, availability);
+	const artifacts = resolveSessionArtifactsDir(ctx.sessionManager.getSessionFile());
+	const activeTools = new Set(pi.getActiveTools());
+	const executeTool = createExecuteTool(pi, activeTools);
+	const create = options.createSessionManager ?? createCodemodeSessionManager;
+	const sessionId = sessionIdFrom(event);
+	const configuredPoolWidth = settings.parallelPoolWidth;
+	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
+	const manager = await create({
+		sessionId,
+		cwd: ctx.cwd,
+		settings,
+		availability,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		complete,
+	});
+	return {
+		sessionId,
+		cwd: ctx.cwd,
+		parallelPoolWidth,
+		manager,
+		enabledLanguages,
+		settings,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		spawns: activeTools.has(settings.taskTools.task),
+	};
+}
+
+export function createExecuteTool(pi: CodemodeRuntimeAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
+	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
+		pi.executeTool(toolName, params, executeOptions);
+	return Object.assign(executeTool, {
+		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
+	});
+}
+
+function sessionIdFrom(event: unknown): string {
+	if (typeof event === "object" && event !== null && "sessionId" in event && typeof event.sessionId === "string") {
+		return event.sessionId;
+	}
+	return crypto.randomUUID();
+}
+
+export function enabledLanguagesFrom(
+	settings: CodemodeSettings,
+	availability: InterpreterAvailability,
+): Record<EvalLanguage, boolean> {
+	return {
+		py: settings.languages.py && availability.py.detected.ok,
+		js: settings.languages.js && availability.js.detected.ok,
+		rb: settings.languages.rb && availability.rb.detected.ok,
+		jl: settings.languages.jl && availability.jl.detected.ok,
+	};
+}

package/src/extension/session-manager-proxy.ts

@@ -0,0 +1,116 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import {
+	CodemodeSessionDisposedError,
+	type CodemodeSessionManager,
+	type EvalExecutionTracker,
+} from "./session-manager.ts";
+
+type TrackedExecution = {
+	readonly promise: Promise<unknown>;
+	readonly controller: AbortController;
+};
+
+export class CodemodeSessionNotStartedError extends Error {
+	readonly name = "CodemodeSessionNotStartedError";
+
+	constructor() {
+		super("codemode session has not started");
+	}
+}
+
+export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
+	#current: CodemodeSessionManager | undefined;
+	#generation = 0;
+	#started = false;
+	#acceptingExecutions = false;
+	readonly #executions = new Set<TrackedExecution>();
+
+	beginReplacement(): number {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		return this.#generation;
+	}
+
+	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		await this.#settleExecutions();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		this.#current = next;
+		this.#started = true;
+		this.#acceptingExecutions = true;
+		return true;
+	}
+
+	assertEvalExecutionAllowed(): void {
+		if (this.#acceptingExecutions && this.#current !== undefined) return;
+		if (this.#started) throw new CodemodeSessionDisposedError();
+		throw new CodemodeSessionNotStartedError();
+	}
+
+	async trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result> {
+		this.assertEvalExecutionAllowed();
+		const tracked: TrackedExecution = { promise: execution, controller };
+		this.#executions.add(tracked);
+		try {
+			return await execution;
+		} finally {
+			this.#executions.delete(tracked);
+		}
+	}
+
+	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.getKernel(language, onMessage);
+	}
+
+	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.complete(request, ctx);
+	}
+
+	setContext(ctx: ExtensionContext): void {
+		this.#current?.setContext?.(ctx);
+	}
+
+	async dispose(): Promise<void> {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		await this.#settleExecutions();
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+	}
+
+	#abortExecutions(): void {
+		if (this.#executions.size === 0) return;
+		const error = new CodemodeSessionDisposedError();
+		for (const execution of this.#executions) execution.controller.abort(error);
+	}
+
+	async #settleExecutions(): Promise<void> {
+		if (this.#executions.size === 0) return;
+		await Promise.allSettled([...this.#executions].map((execution) => execution.promise));
+	}
+}