@selesai/code 0.1.19 → 0.2.0

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -6,7 +6,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
 import type { FSWatcher } from "node:fs";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@selesai/code";
 
 // ============================================================================
 // Basic Types
@@ -982,7 +982,7 @@ export function normalizeMaxSubagentDepth(value: unknown): number | undefined {
 }
 
 export function resolveCurrentMaxSubagentDepth(configMaxDepth?: number): number {
-	return normalizeMaxSubagentDepth(process.env.PI_SUBAGENT_MAX_DEPTH)
+	return normalizeMaxSubagentDepth(process.env.SELESAI_SUBAGENT_MAX_DEPTH)
 		?? normalizeMaxSubagentDepth(configMaxDepth)
 		?? DEFAULT_SUBAGENT_MAX_DEPTH;
 }
@@ -994,18 +994,18 @@ export function resolveChildMaxSubagentDepth(parentMaxDepth: number, agentMaxDep
 }
 
 export function checkSubagentDepth(configMaxDepth?: number): { blocked: boolean; depth: number; maxDepth: number } {
-	const depth = Number(process.env.PI_SUBAGENT_DEPTH ?? "0");
+	const depth = Number(process.env.SELESAI_SUBAGENT_DEPTH ?? "0");
 	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
 	const blocked = Number.isFinite(depth) && depth >= maxDepth;
 	return { blocked, depth, maxDepth };
 }
 
 export function getSubagentDepthEnv(maxDepth?: number): Record<string, string> {
-	const parentDepth = Number(process.env.PI_SUBAGENT_DEPTH ?? "0");
+	const parentDepth = Number(process.env.SELESAI_SUBAGENT_DEPTH ?? "0");
 	const nextDepth = Number.isFinite(parentDepth) ? parentDepth + 1 : 1;
 	return {
-		PI_SUBAGENT_DEPTH: String(nextDepth),
-		PI_SUBAGENT_MAX_DEPTH: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth()),
+		SELESAI_SUBAGENT_DEPTH: String(nextDepth),
+		SELESAI_SUBAGENT_MAX_DEPTH: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth()),
 	};
 }
 

package/dist/extensions/pi-subagents/src/shared/utils.ts

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import * as piCodingAgent from "@earendil-works/pi-coding-agent";
+import * as piCodingAgent from "@selesai/code";
 import type { Message } from "@earendil-works/pi-ai";
 import { formatToolCall } from "./formatters.ts";
 import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult, ToolCallSummary } from "./types.ts";
@@ -14,7 +14,7 @@ import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, Singl
 // File System Utilities
 // ============================================================================
 
-const DEFAULT_CONFIG_DIR_NAME = ".pi";
+const DEFAULT_CONFIG_DIR_NAME = ".selesai";
 
 export function resolveConfigDirName(codingAgentModule: unknown = piCodingAgent): string {
 	const value = codingAgentModule && typeof codingAgentModule === "object"
@@ -32,7 +32,7 @@ export function getProjectConfigDir(projectRoot: string): string {
 }
 
 export function getAgentDir(): string {
-	const configured = process.env.PI_CODING_AGENT_DIR;
+	const configured = process.env.SELESAI_CODING_AGENT_DIR;
 	if (configured === "~") return os.homedir();
 	if (configured?.startsWith("~/")) return path.join(os.homedir(), configured.slice(2));
 	return configured || path.join(os.homedir(), getConfigDirName(), "agent");

package/dist/extensions/pi-subagents/src/slash/slash-bridge.ts

@@ -1,5 +1,5 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@selesai/code";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import {
 	SLASH_SUBAGENT_CANCEL_EVENT,

package/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
 import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll, type ChainConfig } from "../agents/agents.ts";
 import {

package/dist/extensions/pi-subagents/src/tui/render-helpers.ts

@@ -1,4 +1,4 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@selesai/code";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 function fuzzyScore(query: string, text: string): number {

package/dist/extensions/pi-subagents/src/tui/render.ts

@@ -4,7 +4,7 @@
 
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { getMarkdownTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getMarkdownTheme, type ExtensionContext } from "@selesai/code";
 import { Container, Markdown, Spacer, Text, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import {
 	type AgentProgress,

package/dist/extensions/pi-subagents/test/unit/spawn-timing.test.ts

@@ -0,0 +1,45 @@
+import { describe, it } from "node:test";
+import * as assert from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createSpawnTimingMarkers, emitSpawnTiming } from "../../src/runs/shared/spawn-timing.ts";
+
+describe("spawn-timing", () => {
+	it("creates markers with a start time", () => {
+		const markers = createSpawnTimingMarkers();
+		assert.ok(markers.spawnStart > 0);
+	});
+
+	it("emits a timing line when an eventsPath is provided", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-timing-"));
+		const eventsPath = path.join(dir, "events.jsonl");
+		const markers = createSpawnTimingMarkers();
+		emitSpawnTiming({
+			eventsPath,
+			marker: "spawn_start",
+			markers,
+			runId: "run-1",
+			stepIndex: 2,
+			agent: "scout",
+		});
+		const lines = fs.readFileSync(eventsPath, "utf-8").trim().split("\n");
+		assert.equal(lines.length, 1);
+		const event = JSON.parse(lines[0]!);
+		assert.equal(event.type, "subagent.spawn.timing");
+		assert.equal(event.runId, "run-1");
+		assert.equal(event.stepIndex, 2);
+		assert.equal(event.agent, "scout");
+		assert.equal(event.marker, "spawn_start");
+		assert.ok(typeof event.elapsedMs === "number");
+		assert.ok(event.ts > 0);
+		fs.rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("skips emission when eventsPath is missing", () => {
+		const markers = createSpawnTimingMarkers();
+		assert.doesNotThrow(() => {
+			emitSpawnTiming({ eventsPath: undefined, marker: "spawn_start", markers });
+		});
+	});
+});

package/dist/extensions/pi-subagents/tsconfig.runner.json

@@ -0,0 +1,17 @@
+{
+	"extends": "../../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "dist/runner",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"target": "ES2022",
+		"sourceMap": true,
+		"noCheck": true,
+		"noEmitOnError": false,
+		"declaration": false,
+		"declarationMap": false,
+		"inlineSources": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test", "**/*.test.ts"]
+}

package/dist/extensions/pi-web-agent/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@selesai/bundled-pi-web-agent",
+	"version": "1.5.1",
+	"private": true,
+	"description": "Bundled pi-web-agent extension for reliable web access with explicit search, fetch, and headless boundaries. Vendored source-first from @demigodmode/pi-web-agent.",
+	"type": "module",
+	"keywords": [
+		"pi-package",
+		"pi",
+		"extension",
+		"web-search",
+		"web-fetch"
+	],
+	"license": "AGPL-3.0-only",
+	"pi": {
+		"extensions": [
+			"./src/extension.ts"
+		]
+	},
+	"dependencies": {
+		"@mozilla/readability": "^0.6.0",
+		"cheerio": "^1.1.0",
+		"jsdom": "^26.0.0",
+		"playwright": "^1.60.0",
+		"typebox": "^1.1.37"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	}
+}

package/dist/extensions/pi-web-agent/src/backends/config.ts

@@ -0,0 +1,205 @@
+export type SearxngOptions = {
+  categories?: string[];
+  language?: string;
+  safesearch?: 0 | 1 | 2;
+};
+
+export type FirecrawlOptions = {
+  formats?: string[];
+  onlyMainContent?: boolean;
+};
+
+export type SearchBackendConfig = {
+  provider: 'duckduckgo' | 'searxng' | 'brave';
+  baseUrl?: string;
+  fallback?: 'duckduckgo';
+  options?: SearxngOptions;
+};
+
+export type FetchBackendConfig = {
+  provider: 'http' | 'firecrawl';
+  baseUrl?: string;
+  apiKey?: string;
+  fallback?: 'http';
+  options?: FirecrawlOptions;
+};
+export type HeadlessBackendConfig = { provider: 'local-browser' };
+
+export type BackendConfig = {
+  search: SearchBackendConfig;
+  fetch: FetchBackendConfig;
+  headless: HeadlessBackendConfig;
+};
+
+export type BackendConfigOverride = {
+  search?: Partial<SearchBackendConfig>;
+  fetch?: Partial<FetchBackendConfig>;
+  headless?: Partial<HeadlessBackendConfig>;
+};
+
+export type BackendConfigFile = {
+  backends?: {
+    search?: { provider?: unknown; baseUrl?: unknown; fallback?: unknown; options?: unknown };
+    fetch?: { provider?: unknown; baseUrl?: unknown; apiKey?: unknown; fallback?: unknown; options?: unknown };
+    headless?: { provider?: unknown };
+  };
+};
+
+export const DEFAULT_BACKEND_CONFIG: BackendConfig = {
+  search: { provider: 'duckduckgo' },
+  fetch: { provider: 'http' },
+  headless: { provider: 'local-browser' }
+};
+
+function extractStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const strings = value.filter((item): item is string => typeof item === 'string');
+  return strings.length === value.length ? strings : undefined;
+}
+
+function extractSearxngOptions(value: unknown): SearxngOptions | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const raw = value as { categories?: unknown; language?: unknown; safesearch?: unknown };
+  const options: SearxngOptions = {};
+  const categories = extractStringArray(raw.categories);
+  if (categories) options.categories = categories;
+  if (typeof raw.language === 'string') options.language = raw.language;
+  if (raw.safesearch === 0 || raw.safesearch === 1 || raw.safesearch === 2) options.safesearch = raw.safesearch;
+  return Object.keys(options).length > 0 ? options : undefined;
+}
+
+function extractFirecrawlOptions(value: unknown): FirecrawlOptions | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const raw = value as { formats?: unknown; onlyMainContent?: unknown };
+  const options: FirecrawlOptions = {};
+  const formats = extractStringArray(raw.formats);
+  if (formats) options.formats = formats;
+  if (typeof raw.onlyMainContent === 'boolean') options.onlyMainContent = raw.onlyMainContent;
+  return Object.keys(options).length > 0 ? options : undefined;
+}
+
+export function extractBackendConfigOverride(
+  file: BackendConfigFile | null | undefined
+): BackendConfigOverride {
+  const backends = file?.backends;
+  const override: BackendConfigOverride = {};
+
+  if (
+    backends?.search?.provider === 'duckduckgo' ||
+    backends?.search?.provider === 'searxng' ||
+    backends?.search?.provider === 'brave'
+  ) {
+    override.search = { provider: backends.search.provider };
+    if (backends.search.provider === 'searxng' && typeof backends.search.baseUrl === 'string') {
+      override.search.baseUrl = backends.search.baseUrl;
+    }
+    if (backends.search.fallback === 'duckduckgo') {
+      override.search.fallback = 'duckduckgo';
+    }
+    if (backends.search.provider === 'searxng') {
+      const options = extractSearxngOptions(backends.search.options);
+      if (options) {
+        override.search.options = options;
+      }
+    }
+  }
+
+  if (backends?.fetch?.provider === 'http' || backends?.fetch?.provider === 'firecrawl') {
+    override.fetch = { provider: backends.fetch.provider };
+    if (typeof backends.fetch.baseUrl === 'string') {
+      override.fetch.baseUrl = backends.fetch.baseUrl;
+    }
+    if (typeof backends.fetch.apiKey === 'string') {
+      override.fetch.apiKey = backends.fetch.apiKey;
+    }
+    if (backends.fetch.fallback === 'http') {
+      override.fetch.fallback = 'http';
+    }
+    const options = extractFirecrawlOptions(backends.fetch.options);
+    if (options) {
+      override.fetch.options = options;
+    }
+  }
+
+  if (backends?.headless?.provider === 'local-browser') {
+    override.headless = { provider: 'local-browser' };
+  }
+
+  return override;
+}
+
+export function validateBackendConfig(config: BackendConfig): string[] {
+  const issues: string[] = [];
+
+  if (config.search.provider === 'searxng' && !config.search.baseUrl) {
+    issues.push('search provider searxng requires backends.search.baseUrl');
+  }
+
+  if (config.fetch.provider === 'firecrawl' && !config.fetch.baseUrl) {
+    issues.push('fetch provider firecrawl requires backends.fetch.baseUrl');
+  }
+
+  if (config.search.fallback === 'duckduckgo' && config.search.provider !== 'searxng' && config.search.provider !== 'brave') {
+    issues.push('search fallback duckduckgo is only supported when search provider is searxng or brave');
+  }
+
+  if (config.fetch.fallback === 'http' && config.fetch.provider !== 'firecrawl') {
+    issues.push('fetch fallback http is only supported when fetch provider is firecrawl');
+  }
+
+  if (config.search.options?.categories && config.search.options.categories.length === 0) {
+    issues.push('search options.categories must contain at least one category when provided');
+  }
+
+  if (config.search.options?.language !== undefined && !config.search.options.language.trim()) {
+    issues.push('search options.language must not be empty when provided');
+  }
+
+  if (
+    config.search.options?.safesearch !== undefined &&
+    ![0, 1, 2].includes(config.search.options.safesearch)
+  ) {
+    issues.push('search options.safesearch must be 0, 1, or 2 when provided');
+  }
+
+  if (config.fetch.options?.formats && config.fetch.options.formats.length === 0) {
+    issues.push('fetch options.formats must contain at least one format when provided');
+  }
+
+  return issues;
+}
+
+function mergeSearchConfig(
+  current: SearchBackendConfig,
+  override: Partial<SearchBackendConfig> | undefined
+): SearchBackendConfig {
+  if (!override) return current;
+  if (override.provider && override.provider !== current.provider) {
+    return { ...override, provider: override.provider };
+  }
+  return { ...current, ...override };
+}
+
+function mergeFetchConfig(
+  current: FetchBackendConfig,
+  override: Partial<FetchBackendConfig> | undefined
+): FetchBackendConfig {
+  if (!override) return current;
+  if (override.provider && override.provider !== current.provider) {
+    return { ...override, provider: override.provider };
+  }
+  return { ...current, ...override };
+}
+
+export function mergeBackendConfigLayers(
+  ...layers: Array<BackendConfig | BackendConfigOverride | undefined>
+): BackendConfig {
+  return layers.reduce<BackendConfig>(
+    (merged, layer) => ({
+      search: mergeSearchConfig(merged.search, layer?.search),
+      fetch: mergeFetchConfig(merged.fetch, layer?.fetch),
+      headless: { ...merged.headless, ...layer?.headless }
+    }),
+    DEFAULT_BACKEND_CONFIG
+  );
+}

package/dist/extensions/pi-web-agent/src/backends/doctor.ts

@@ -0,0 +1,136 @@
+import type { BackendConfig, FirecrawlOptions, SearxngOptions } from './config.js';
+import { readBraveKeyFromSettings } from './settings-reader.js';
+
+function withTimeout(timeoutMs: number) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  return { signal: controller.signal, done: () => clearTimeout(timeout) };
+}
+
+function message(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function braveDoctorUrl() {
+  const url = new URL('https://api.search.brave.com/res/v1/web/search');
+  url.searchParams.set('q', 'pi-web-agent-doctor');
+  url.searchParams.set('count', '1');
+  return url.toString();
+}
+
+function searxngDoctorUrl(baseUrl: string, options: SearxngOptions = {}) {
+  const url = new URL('/search', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+  url.searchParams.set('q', 'pi-web-agent-doctor');
+  url.searchParams.set('format', 'json');
+  if (options.categories?.length) url.searchParams.set('categories', options.categories.join(','));
+  if (options.language) url.searchParams.set('language', options.language);
+  if (options.safesearch !== undefined) url.searchParams.set('safesearch', String(options.safesearch));
+  return url.toString();
+}
+
+function firecrawlDoctorBody(options: FirecrawlOptions = {}) {
+  return {
+    url: 'https://example.com',
+    formats: options.formats ?? ['markdown'],
+    ...(options.onlyMainContent !== undefined ? { onlyMainContent: options.onlyMainContent } : {})
+  };
+}
+
+export async function checkBackendHealth(
+  config: BackendConfig,
+  {
+    fetchImpl = fetch,
+    timeoutMs = 3_000
+  }: {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+  } = {}
+): Promise<string[]> {
+  const lines: string[] = [];
+
+  if (config.search.provider === 'duckduckgo') {
+    lines.push('search backend: duckduckgo');
+  } else if (config.search.provider === 'brave') {
+    const apiKey = process.env.PI_WEB_AGENT_BRAVE_API_KEY ?? readBraveKeyFromSettings();
+    if (!apiKey?.trim()) {
+      lines.push('search backend: brave warning (missing Brave API key — set webAgent.braveApiKey in settings.json or PI_WEB_AGENT_BRAVE_API_KEY env var)');
+    } else {
+      const timeout = withTimeout(timeoutMs);
+      try {
+        const response = await fetchImpl(braveDoctorUrl(), {
+          headers: {
+            Accept: 'application/json',
+            'X-Subscription-Token': apiKey
+          },
+          signal: timeout.signal
+        });
+        if (!response.ok) {
+          lines.push(`search backend: brave warning (HTTP ${response.status})`);
+        } else {
+          const json = (await response.json()) as { web?: { results?: unknown } };
+          lines.push(Array.isArray(json.web?.results)
+            ? 'search backend: brave ok'
+            : 'search backend: brave warning (unexpected response)');
+        }
+      } catch (error) {
+        lines.push(`search backend: brave warning (${message(error)})`);
+      } finally {
+        timeout.done();
+      }
+    }
+  } else if (!config.search.baseUrl) {
+    lines.push('search backend: searxng warning (missing baseUrl)');
+  } else {
+    const timeout = withTimeout(timeoutMs);
+    try {
+      const response = await fetchImpl(searxngDoctorUrl(config.search.baseUrl, config.search.options), { signal: timeout.signal });
+      const json = (await response.json()) as { results?: unknown };
+      lines.push(response.ok && Array.isArray(json.results)
+        ? 'search backend: searxng ok'
+        : 'search backend: searxng warning (unexpected response)');
+    } catch (error) {
+      lines.push(`search backend: searxng warning (${message(error)})`);
+    } finally {
+      timeout.done();
+    }
+  }
+
+  if (config.search.fallback) {
+    lines.push(`search fallback: ${config.search.fallback}`);
+  }
+
+  if (config.fetch.provider === 'http') {
+    lines.push('fetch backend: http');
+  } else if (!config.fetch.baseUrl) {
+    lines.push('fetch backend: firecrawl warning (missing baseUrl)');
+  } else {
+    const timeout = withTimeout(timeoutMs);
+    try {
+      const headers: Record<string, string> = { 'content-type': 'application/json' };
+      if (config.fetch.apiKey ?? process.env.PI_WEB_AGENT_FIRECRAWL_API_KEY) {
+        headers.Authorization = `Bearer ${config.fetch.apiKey ?? process.env.PI_WEB_AGENT_FIRECRAWL_API_KEY}`;
+      }
+      const response = await fetchImpl(new URL('/v1/scrape', config.fetch.baseUrl).toString(), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(firecrawlDoctorBody(config.fetch.options)),
+        signal: timeout.signal
+      });
+      lines.push(response.ok ? 'fetch backend: firecrawl ok' : `fetch backend: firecrawl warning (HTTP ${response.status})`);
+    } catch (error) {
+      lines.push(`fetch backend: firecrawl warning (${message(error)})`);
+    } finally {
+      timeout.done();
+    }
+  }
+
+  if (config.fetch.fallback) {
+    lines.push(`fetch fallback: ${config.fetch.fallback}`);
+  }
+
+  if (config.headless.provider === 'local-browser') {
+    lines.push('headless backend: local-browser (managed Chromium fallback configured)');
+  }
+
+  return lines;
+}