one-code-extension 0.1.4 → 0.3.1

package/extensions/doctor/build.ts

@@ -0,0 +1,226 @@
+/**
+ * Assemble the doctor report from gathered inputs (pure).
+ *
+ * Section order is the order a first-session user needs answers in: is the
+ * install sound, is any provider ready, which model does each role get, what
+ * would the presets change, what of my Claude Code setup was picked up, are my
+ * MCP servers reachable, what external programs are missing — then the issues.
+ */
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { extensionVersion } from "../lib/package-version.ts";
+import { piVersionWarning, TESTED_PI_MAX_EXCLUSIVE, TESTED_PI_MIN } from "../lib/pi-version.ts";
+import { modelSpec } from "../lib/model-policy.ts";
+import { readJsonFile } from "../lib/atomic-write.ts";
+import { oneCodeSettingsPath } from "../lib/one-code-settings.ts";
+import { webSearchSettingsFrom } from "../web/backends.ts";
+import { collectCompat, importedConfigSection, mcpSection } from "./compat.ts";
+import { checkDependencies, dependenciesSection } from "./dependencies.ts";
+import { collectModelFacts, modelsSection } from "./models.ts";
+import { computePresets, presetsSection } from "./presets.ts";
+import {
+	countNoun,
+	type DoctorEnvironment,
+	type DoctorReport,
+	type Finding,
+	type RegistryView,
+	REPORT_TITLE,
+	type ReportLine,
+	type ReportSection,
+	type SessionView,
+	shortenHome,
+} from "./report.ts";
+
+export const BUNDLED_AGENTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
+
+/** The environment variables a first-time user is most likely to already have; hinted when nothing is configured. */
+export const COMMON_KEY_ENV_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "OPENROUTER_API_KEY", "OPENCODE_API_KEY"];
+
+const AUTH_SOURCE_LABEL: Record<string, string> = {
+	stored: "key saved by /login",
+	environment: "environment variable",
+	runtime: "provided by an extension",
+	fallback: "default credentials",
+	models_json_key: "key in models.json",
+	models_json_command: "key command in models.json",
+};
+
+export function installationSection(env: DoctorEnvironment, findings: Finding[]): ReportSection {
+	const lines: ReportLine[] = [];
+	const pi = env.piVersion ? ` · pi ${env.piVersion}` : "";
+	lines.push({
+		text: env.install === "app" ? `Running: the bundled onecode app ${env.oneCodeVersion}${pi}` : `Running: one-code-extension ${env.oneCodeVersion} on your own pi${pi}`,
+		level: "ok",
+	});
+	lines.push({ text: `Node ${env.nodeVersion} · ${env.platform}-${env.arch}`, level: "dim" });
+	lines.push({ text: `pi agent dir: ${shortenHome(env.agentDir, env.home)} (auth, models, sessions, pi settings)`, level: "dim" });
+	lines.push({ text: `One Code state: ${shortenHome(env.stateDir, env.home)} (own settings, plans)`, level: "dim" });
+	const claudeDir = env.env.CLAUDE_CONFIG_DIR ? `${env.env.CLAUDE_CONFIG_DIR} (CLAUDE_CONFIG_DIR)` : shortenHome(`${env.home}/.claude`, env.home);
+	lines.push({ text: `Claude Code config read from: ${claudeDir} (never written)`, level: "dim" });
+
+	const versionWarning = piVersionWarning(env.piVersion);
+	if (versionWarning) {
+		lines.push({ text: `pi ${env.piVersion} is outside the tested range ${TESTED_PI_MIN} – <${TESTED_PI_MAX_EXCLUSIVE}`, level: "warn" });
+		findings.push({ level: "warn", text: versionWarning, fix: env.install === "app" ? "Upgrade One Code (it pins a tested pi)." : "Update one-code-extension, or pin pi inside the tested range." });
+	}
+
+	if (env.latest) {
+		switch (env.latest.status) {
+			case "current":
+				lines.push({ text: `Updates: up to date (${env.oneCodeVersion} is the latest release)`, level: "ok" });
+				break;
+			case "behind":
+				lines.push({
+					text: `Updates: ${env.latest.version} is available (you have ${env.oneCodeVersion}) — ${env.install === "app" ? "npm install -g @one-ai/one-code" : "pi update"}`,
+					level: "warn",
+				});
+				break;
+			case "skipped":
+				lines.push({ text: `Updates: check skipped (${env.latest.reason ?? "offline"})`, level: "dim" });
+				break;
+			default:
+				lines.push({ text: `Updates: could not check the registry${env.latest.reason ? ` (${env.latest.reason})` : ""}`, level: "dim" });
+		}
+	}
+	return { title: "Installation", lines };
+}
+
+export interface ProviderSummary {
+	provider: string;
+	name: string;
+	ready: boolean;
+	source?: string;
+	models: number;
+	available: number;
+}
+
+export function summarizeProviders(registry: RegistryView): ProviderSummary[] {
+	const byProvider = new Map<string, { models: number; available: number }>();
+	for (const model of registry.all) {
+		const entry = byProvider.get(model.provider) ?? { models: 0, available: 0 };
+		entry.models++;
+		byProvider.set(model.provider, entry);
+	}
+	for (const model of registry.available) {
+		const entry = byProvider.get(model.provider) ?? { models: 0, available: 0 };
+		entry.available++;
+		byProvider.set(model.provider, entry);
+	}
+	const out: ProviderSummary[] = [];
+	for (const [provider, counts] of byProvider) {
+		let status: { configured: boolean; source?: string; label?: string } = { configured: false };
+		try {
+			status = registry.authStatus(provider);
+		} catch {
+			// a provider the registry cannot answer for counts as not configured
+		}
+		const ready = status.configured || counts.available > 0;
+		const source = status.source ? AUTH_SOURCE_LABEL[status.source] ?? status.source : undefined;
+		out.push({
+			provider,
+			name: registry.displayName?.(provider) ?? provider,
+			ready,
+			source: source && status.label && status.source === "environment" ? `${source} ${status.label}` : source,
+			models: counts.models,
+			available: counts.available,
+		});
+	}
+	return out.sort((a, b) => Number(b.ready) - Number(a.ready) || a.provider.localeCompare(b.provider));
+}
+
+export function providersSection(registry: RegistryView, findings: Finding[]): { section: ReportSection; readyCount: number } {
+	const providers = summarizeProviders(registry);
+	const ready = providers.filter((p) => p.ready);
+	const lines: ReportLine[] = [];
+	for (const provider of ready) {
+		const models = provider.available || provider.models;
+		lines.push({
+			text: `${provider.name} (${provider.provider}): ready — ${provider.source ?? "credentials configured"} · ${countNoun(models, "model")}`,
+			level: "ok",
+		});
+	}
+	const rest = providers.length - ready.length;
+	if (ready.length === 0) {
+		lines.push({ text: `No provider has credentials (${rest} known providers)`, level: "error" });
+		findings.push({
+			level: "error",
+			text: "No model provider is configured, so no session can send a request yet.",
+			fix: `Run /login inside One Code, or export a key such as ${COMMON_KEY_ENV_VARS.slice(0, 2).join(" or ")} before launching. Free options: OpenCode Zen (deepseek-v4-flash-free) and OpenRouter's :free models.`,
+		});
+	} else if (rest > 0) {
+		lines.push({ text: `${countNoun(rest, "more provider")} without credentials — /login to add one, or set its API-key environment variable`, level: "dim" });
+	}
+	return { section: { title: "Providers", lines }, readyCount: ready.length };
+}
+
+export interface BuildInput {
+	env: DoctorEnvironment;
+	registry: RegistryView;
+	session: SessionView;
+}
+
+export function buildDoctorReport({ env, registry, session }: BuildInput): DoctorReport {
+	const findings: Finding[] = [];
+	const sections: ReportSection[] = [];
+
+	sections.push(installationSection(env, findings));
+	const providers = providersSection(registry, findings);
+	sections.push(providers.section);
+
+	const facts = collectModelFacts(registry.available, session, env.home, env.env);
+	sections.push(modelsSection(facts, session, findings));
+
+	const presets = computePresets(registry.available, session.model);
+	sections.push(presetsSection(presets, session.model));
+
+	const compat = collectCompat({ cwd: env.cwd, home: env.home, agentDir: env.agentDir, env: env.env, bundledAgentsDir: BUNDLED_AGENTS_DIR });
+	findings.push(...compat.findings);
+	sections.push(importedConfigSection(compat, env.home));
+	sections.push(mcpSection(compat, session, env.home));
+
+	const webSearchSettings = webSearchSettingsFrom(readJsonFile<{ webSearch?: unknown }>(oneCodeSettingsPath(env.home, env.env))?.webSearch);
+	const deps = checkDependencies({ cwd: env.cwd, env: env.env, platform: env.platform, mcpServers: compat.mcp.servers, sessionModel: session.model, webSearchSettings });
+	findings.push(...deps.findings);
+	sections.push(dependenciesSection(deps));
+
+	// Errors first, then warnings, in discovery order within each.
+	findings.sort((a, b) => Number(b.level === "error") - Number(a.level === "error"));
+	const ready = providers.readyCount > 0 && session.model !== undefined && !findings.some((f) => f.level === "error");
+
+	return {
+		title: REPORT_TITLE,
+		summary: summaryText({ ready, providersReady: providers.readyCount, main: session.model, subagent: facts.subagent.model, classifier: facts.classifier.model, files: compat.files.filter((f) => f.exists).length, contextFiles: compat.contextFiles.length, findings }),
+		sections,
+		findings,
+		ready,
+	};
+}
+
+function summaryText(input: {
+	ready: boolean;
+	providersReady: number;
+	main?: Model<Api>;
+	subagent?: Model<Api>;
+	classifier?: Model<Api>;
+	files: number;
+	contextFiles: number;
+	findings: Finding[];
+}): string {
+	const errors = input.findings.filter((f) => f.level === "error").length;
+	const warnings = input.findings.length - errors;
+	const config = `${countNoun(input.files, "settings file")} and ${countNoun(input.contextFiles, "instruction file")} are in use.`;
+	if (input.providersReady === 0 || !input.main) {
+		return `Not ready: no model provider has credentials, so nothing can run yet. Connect one with /login (or an API-key environment variable), then rerun /doctor. ${config}`;
+	}
+	const roles = `Main model ${modelSpec(input.main)}${input.subagent ? `, subagents on ${modelSpec(input.subagent)}` : ""}${input.classifier ? `, auto-mode classifier ${modelSpec(input.classifier)}` : ""}.`;
+	if (!input.ready) return `${countNoun(errors, "problem")} need${errors === 1 ? "s" : ""} attention (listed at the bottom). ${roles} ${config}`;
+	const tail = warnings ? `${countNoun(warnings, "warning")} below; none blocks a session.` : "No issues found.";
+	return `Ready. ${roles} ${config} ${tail}`;
+}
+
+/** The extension's own version — the app overrides it with CC_VERSION (lockstep releases). */
+export function oneCodeVersion(env: NodeJS.ProcessEnv = process.env): string {
+	return env.CC_VERSION ?? extensionVersion();
+}

package/extensions/doctor/cli.ts

@@ -0,0 +1,99 @@
+/**
+ * `onecode doctor` — the report without a session, Claude Code's `claude doctor`.
+ *
+ * The bundled app (app/bin.mjs) loads this file through pi's own TypeScript
+ * loader (jiti) and calls `runDoctorCli` before pi's `main()` would ever run,
+ * so it works on the machine the doctor exists for: one with no provider yet,
+ * where pi's session bootstrap has nothing to start. Reads pi's auth and model
+ * files through pi's own `ModelRuntime`/`ModelRegistry` (no network) and pi's
+ * saved default model through `SettingsManager`; everything else is the same
+ * `buildDoctorReport` the `/doctor` command uses.
+ */
+
+import { join } from "node:path";
+import { ModelRegistry, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { oneCodeStateDir } from "../lib/paths.ts";
+import { loadPermissionSettings } from "../permissions/settings.ts";
+import { buildDoctorReport } from "./build.ts";
+import { type DoctorReport, renderDoctorText, type SessionView } from "./report.ts";
+import { lookupLatestVersion } from "./update-lookup.ts";
+
+export interface DoctorCliOptions {
+	agentDir: string;
+	cwd: string;
+	home: string;
+	env: NodeJS.ProcessEnv;
+	version: string;
+	install: "app" | "pi-package";
+	piVersion?: string;
+	/** Report width; defaults to the terminal's columns, else 100. */
+	columns?: number;
+	/** Skip the registry version lookup (tests). */
+	network?: boolean;
+}
+
+/** Build the report headlessly. Exported separately so tests can inspect the structure. */
+export async function collectDoctorCliReport(options: DoctorCliOptions): Promise<DoctorReport> {
+	const { agentDir, cwd, home, env } = options;
+	// The registry lookup (network, up to 3s) overlaps the local runtime load.
+	const latestPending = options.network === false ? undefined : lookupLatestVersion({ install: options.install, current: options.version, env });
+	const runtime = await ModelRuntime.create({
+		authPath: join(agentDir, "auth.json"),
+		modelsPath: join(agentDir, "models.json"),
+		allowModelNetwork: false,
+	});
+	const registry = new ModelRegistry(runtime);
+	const settings = SettingsManager.create(cwd, agentDir);
+
+	const available = registry.getAvailable();
+	const defaultProvider = settings.getDefaultProvider();
+	const defaultModel = settings.getDefaultModel();
+	const saved = defaultProvider && defaultModel ? registry.find(defaultProvider, defaultModel) : undefined;
+	const session: SessionView = saved
+		? { model: saved, modelSource: "default-setting" }
+		: available[0]
+			? { model: available[0], modelSource: "first-available" }
+			: { modelSource: "none" };
+	session.thinkingLevel = settings.getDefaultThinkingLevel();
+	const permissions = loadPermissionSettings(cwd, home);
+	session.permission = {
+		mode: permissions.defaultMode ?? "auto",
+		source: permissions.defaultMode ? "permissions.defaultMode in settings" : "One Code's default",
+	};
+
+	const latest = await latestPending;
+	return buildDoctorReport({
+		env: {
+			cwd,
+			home,
+			agentDir,
+			stateDir: oneCodeStateDir(env, home),
+			env,
+			platform: process.platform,
+			arch: process.arch,
+			nodeVersion: process.versions.node,
+			oneCodeVersion: options.version,
+			install: options.install,
+			piVersion: options.piVersion,
+			latest,
+		},
+		registry: {
+			all: registry.getAll(),
+			available,
+			authStatus: (provider) => registry.getProviderAuthStatus(provider),
+			displayName: (provider) => registry.getProviderDisplayName(provider),
+		},
+		session,
+	});
+}
+
+/** Print the report; exit code 1 when an error-level finding means a session cannot work yet. */
+export async function runDoctorCli(options: DoctorCliOptions, write: (text: string) => void = (text) => process.stdout.write(text)): Promise<number> {
+	const report = await collectDoctorCliReport(options);
+	const width = options.columns ?? process.stdout.columns ?? 100;
+	write(`${renderDoctorText(report, Math.max(60, Math.min(width, 120)))}\n\n`);
+	const where = options.install === "app" ? "an onecode session" : "a pi session";
+	write(`For a full setup checkup that can also fix issues, run /doctor inside ${where}.\n`);
+	write("Inside a session, /doctor report shows this report alone.\n");
+	return report.findings.some((finding) => finding.level === "error") ? 1 : 0;
+}