@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/resource-loader.d.ts

@@ -0,0 +1,206 @@
+import { type Theme } from "../modes/interactive/theme/theme.ts";
+import type { ResourceDiagnostic } from "./diagnostics.ts";
+export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.ts";
+import { type EventBus } from "./event-bus.ts";
+import type { InlineExtension, LoadExtensionsResult } from "./extensions/types.ts";
+import { type PathMetadata } from "./package-manager.ts";
+import type { PromptTemplate } from "./prompt-templates.ts";
+import { SettingsManager } from "./settings-manager.ts";
+import type { Skill } from "./skills.ts";
+export interface ResourceExtensionPaths {
+    skillPaths?: Array<{
+        path: string;
+        metadata: PathMetadata;
+    }>;
+    promptPaths?: Array<{
+        path: string;
+        metadata: PathMetadata;
+    }>;
+    themePaths?: Array<{
+        path: string;
+        metadata: PathMetadata;
+    }>;
+}
+export interface ResourceLoaderReloadOptions {
+    resolveProjectTrust?: (input: {
+        extensionsResult: LoadExtensionsResult;
+    }) => Promise<boolean>;
+}
+export interface ResourceLoader {
+    getExtensions(): LoadExtensionsResult;
+    getSkills(): {
+        skills: Skill[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getPrompts(): {
+        prompts: PromptTemplate[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getThemes(): {
+        themes: Theme[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getAgentsFiles(): {
+        agentsFiles: Array<{
+            path: string;
+            content: string;
+        }>;
+    };
+    getSystemPrompt(): string | undefined;
+    getAppendSystemPrompt(): string[];
+    extendResources(paths: ResourceExtensionPaths): void;
+    reload(options?: ResourceLoaderReloadOptions): Promise<void>;
+}
+export declare function loadProjectContextFiles(options: {
+    cwd: string;
+    agentDir: string;
+}): Array<{
+    path: string;
+    content: string;
+}>;
+export interface DefaultResourceLoaderOptions {
+    cwd: string;
+    agentDir: string;
+    settingsManager?: SettingsManager;
+    eventBus?: EventBus;
+    additionalExtensionPaths?: string[];
+    additionalSkillPaths?: string[];
+    additionalPromptTemplatePaths?: string[];
+    additionalThemePaths?: string[];
+    extensionFactories?: InlineExtension[];
+    noExtensions?: boolean;
+    noSkills?: boolean;
+    noPromptTemplates?: boolean;
+    noThemes?: boolean;
+    noContextFiles?: boolean;
+    systemPrompt?: string;
+    appendSystemPrompt?: string[];
+    extensionsOverride?: (base: LoadExtensionsResult) => LoadExtensionsResult;
+    skillsOverride?: (base: {
+        skills: Skill[];
+        diagnostics: ResourceDiagnostic[];
+    }) => {
+        skills: Skill[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    promptsOverride?: (base: {
+        prompts: PromptTemplate[];
+        diagnostics: ResourceDiagnostic[];
+    }) => {
+        prompts: PromptTemplate[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    themesOverride?: (base: {
+        themes: Theme[];
+        diagnostics: ResourceDiagnostic[];
+    }) => {
+        themes: Theme[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    agentsFilesOverride?: (base: {
+        agentsFiles: Array<{
+            path: string;
+            content: string;
+        }>;
+    }) => {
+        agentsFiles: Array<{
+            path: string;
+            content: string;
+        }>;
+    };
+    systemPromptOverride?: (base: string | undefined) => string | undefined;
+    appendSystemPromptOverride?: (base: string[]) => string[];
+}
+export declare class DefaultResourceLoader implements ResourceLoader {
+    private cwd;
+    private agentDir;
+    private settingsManager;
+    private eventBus;
+    private packageManager;
+    private additionalExtensionPaths;
+    private additionalSkillPaths;
+    private additionalPromptTemplatePaths;
+    private additionalThemePaths;
+    private extensionFactories;
+    private noExtensions;
+    private noSkills;
+    private noPromptTemplates;
+    private noThemes;
+    private noContextFiles;
+    private systemPromptSource?;
+    private appendSystemPromptSource?;
+    private extensionsOverride?;
+    private skillsOverride?;
+    private promptsOverride?;
+    private themesOverride?;
+    private agentsFilesOverride?;
+    private systemPromptOverride?;
+    private appendSystemPromptOverride?;
+    private extensionsResult;
+    private skills;
+    private skillDiagnostics;
+    private prompts;
+    private promptDiagnostics;
+    private themes;
+    private themeDiagnostics;
+    private agentsFiles;
+    private systemPrompt?;
+    private appendSystemPrompt;
+    private lastSkillPaths;
+    private extensionSkillSourceInfos;
+    private extensionPromptSourceInfos;
+    private extensionThemeSourceInfos;
+    private lastPromptPaths;
+    private lastThemePaths;
+    private loaded;
+    constructor(options: DefaultResourceLoaderOptions);
+    getExtensions(): LoadExtensionsResult;
+    getSkills(): {
+        skills: Skill[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getPrompts(): {
+        prompts: PromptTemplate[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getThemes(): {
+        themes: Theme[];
+        diagnostics: ResourceDiagnostic[];
+    };
+    getAgentsFiles(): {
+        agentsFiles: Array<{
+            path: string;
+            content: string;
+        }>;
+    };
+    getSystemPrompt(): string | undefined;
+    getAppendSystemPrompt(): string[];
+    extendResources(paths: ResourceExtensionPaths): void;
+    loadProjectTrustExtensions(): Promise<LoadExtensionsResult>;
+    reload(options?: ResourceLoaderReloadOptions): Promise<void>;
+    private loadCurrentExtensionSet;
+    private resolveExtensionLoadPath;
+    private loadFinalExtensionSet;
+    private addExtensionConflictDiagnostics;
+    private mapSkillPath;
+    private normalizeExtensionPaths;
+    private updateSkillsFromPaths;
+    private updatePromptsFromPaths;
+    private updateThemesFromPaths;
+    private applyExtensionSourceInfo;
+    private findSourceInfoForPath;
+    private getDefaultSourceInfoForPath;
+    private mergePaths;
+    private resolveResourcePath;
+    private loadThemes;
+    private loadThemesFromDir;
+    private loadThemeFromFile;
+    private loadExtensionFactories;
+    private dedupePrompts;
+    private dedupeThemes;
+    private discoverSystemPromptFile;
+    private discoverAppendSystemPromptFile;
+    private isUnderPath;
+    private detectExtensionConflicts;
+}
+//# sourceMappingURL=resource-loader.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/runtime-credentials.d.ts

@@ -0,0 +1,15 @@
+import type { Credential, CredentialInfo, CredentialStore } from "@earendil-works/pi-ai";
+/** Async credential store overlay for non-persistent runtime API keys. */
+export declare class RuntimeCredentials implements CredentialStore {
+    private readonly store;
+    private readonly overrides;
+    constructor(store: CredentialStore);
+    setRuntimeApiKey(providerId: string, apiKey: string): void;
+    removeRuntimeApiKey(providerId: string): void;
+    hasRuntimeApiKey(providerId: string): boolean;
+    read(providerId: string): Promise<Credential | undefined>;
+    list(): Promise<readonly CredentialInfo[]>;
+    modify(providerId: string, fn: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;
+    delete(providerId: string): Promise<void>;
+}
+//# sourceMappingURL=runtime-credentials.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/sdk.d.ts

@@ -0,0 +1,106 @@
+import { type ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { type Model } from "@earendil-works/pi-ai/compat";
+import { AgentSession } from "./agent-session.ts";
+import type { LoadExtensionsResult, SessionStartEvent, ToolDefinition } from "./extensions/index.ts";
+import { ModelRuntime } from "./model-runtime.ts";
+import type { ResourceLoader } from "./resource-loader.ts";
+import { SessionManager } from "./session-manager.ts";
+import { SettingsManager } from "./settings-manager.ts";
+import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue } from "./tools/index.ts";
+export interface CreateAgentSessionOptions {
+    /** Working directory for project-local discovery. Default: process.cwd() */
+    cwd?: string;
+    /** Global config directory. Default: ~/.selesai/agent */
+    agentDir?: string;
+    /** Canonical model/auth runtime. Defaults to a runtime using agentDir/auth.json and models.json. */
+    modelRuntime?: ModelRuntime;
+    /** Model to use. Default: from settings, else first available */
+    model?: Model<any>;
+    /** Thinking level. Default: from settings, else 'medium' (clamped to model capabilities) */
+    thinkingLevel?: ThinkingLevel;
+    /** Models available for cycling (Ctrl+P in interactive mode) */
+    scopedModels?: Array<{
+        model: Model<any>;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    /**
+     * Optional default tool suppression mode when no explicit allowlist is provided.
+     *
+     * - "all": start with no tools enabled
+     * - "builtin": disable the default built-in tools (read, bash, edit, write)
+     *   but keep extension/custom tools enabled
+     */
+    noTools?: "all" | "builtin";
+    /**
+     * Optional allowlist of tool names.
+     *
+     * When omitted, pi enables the default built-in tools (read, bash, edit, write)
+     * and leaves extension/custom tools enabled unless `noTools` changes that default.
+     * When provided, only the listed tool names are enabled.
+     */
+    tools?: string[];
+    /** Optional denylist of tool names to disable. Applies after `tools` when both are provided. */
+    excludeTools?: string[];
+    /** Custom tools to register (in addition to built-in tools). */
+    customTools?: ToolDefinition[];
+    /** Resource loader. When omitted, DefaultResourceLoader is used. */
+    resourceLoader?: ResourceLoader;
+    /** Session manager. Default: SessionManager.create(cwd) */
+    sessionManager?: SessionManager;
+    /** Settings manager. Default: SettingsManager.create(cwd, agentDir) */
+    settingsManager?: SettingsManager;
+    /** Session start event metadata for extension runtime startup. */
+    sessionStartEvent?: SessionStartEvent;
+}
+/** Result from createAgentSession */
+export interface CreateAgentSessionResult {
+    /** The created session */
+    session: AgentSession;
+    /** Extensions result (for UI context setup in interactive mode) */
+    extensionsResult: LoadExtensionsResult;
+    /** Warning if session was restored with a different model than saved */
+    modelFallbackMessage?: string;
+}
+export * from "./agent-session-runtime.ts";
+export type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionFactory, InlineExtension, SlashCommandInfo, SlashCommandSource, ToolDefinition, } from "./extensions/index.ts";
+export type { PromptTemplate } from "./prompt-templates.ts";
+export type { Skill } from "./skills.ts";
+export type { Tool } from "./tools/index.ts";
+export { withFileMutationQueue, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+/**
+ * Create an AgentSession with the specified options.
+ *
+ * @example
+ * ```typescript
+ * // Minimal - uses defaults
+ * const { session } = await createAgentSession();
+ *
+ * // With explicit model
+ * import { getModel } from '@earendil-works/pi-ai';
+ * const { session } = await createAgentSession({
+ *   model: getModel('anthropic', 'claude-opus-4-5'),
+ *   thinkingLevel: 'high',
+ * });
+ *
+ * // Continue previous session
+ * const { session, modelFallbackMessage } = await createAgentSession({
+ *   continueSession: true,
+ * });
+ *
+ * // Full control
+ * const loader = new DefaultResourceLoader({
+ *   cwd: process.cwd(),
+ *   agentDir: getAgentDir(),
+ *   settingsManager: SettingsManager.create(),
+ * });
+ * await loader.reload();
+ * const { session } = await createAgentSession({
+ *   model: myModel,
+ *   tools: ["read", "bash"],
+ *   resourceLoader: loader,
+ *   sessionManager: SessionManager.inMemory(),
+ * });
+ * ```
+ */
+export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;
+//# sourceMappingURL=sdk.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/session-cwd.d.ts

@@ -0,0 +1,19 @@
+export interface SessionCwdIssue {
+    sessionFile?: string;
+    sessionCwd: string;
+    fallbackCwd: string;
+}
+interface SessionCwdSource {
+    getCwd(): string;
+    getSessionFile(): string | undefined;
+}
+export declare function getMissingSessionCwdIssue(sessionManager: SessionCwdSource, fallbackCwd: string): SessionCwdIssue | undefined;
+export declare function formatMissingSessionCwdError(issue: SessionCwdIssue): string;
+export declare function formatMissingSessionCwdPrompt(issue: SessionCwdIssue): string;
+export declare class MissingSessionCwdError extends Error {
+    readonly issue: SessionCwdIssue;
+    constructor(issue: SessionCwdIssue);
+}
+export declare function assertSessionCwdExists(sessionManager: SessionCwdSource, fallbackCwd: string): void;
+export {};
+//# sourceMappingURL=session-cwd.d.ts.map