@jawcode-dev/coding-agent 1.1.0

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -0,0 +1,60 @@
+import { type CanonicalJwcWorkflowSkill } from "./active-state";
+export { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION, WORKFLOW_STATE_VERSION, } from "./workflow-state-version";
+export type { CanonicalJwcWorkflowSkill };
+export type WorkflowStateMutationOwner = "jwc-state-cli" | "jwc-runtime" | "jwc-hook";
+/** gjc-era receipts persist legacy owner strings — normalize on read (260613 flip, read-both). */
+export declare const LEGACY_WORKFLOW_STATE_OWNER_ALIASES: Record<string, WorkflowStateMutationOwner>;
+export declare function normalizeWorkflowStateOwner(value: unknown): WorkflowStateMutationOwner | undefined;
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+export interface WorkflowStateContentChecksum {
+    algorithm: "sha256";
+    value: string;
+    covered_path: string;
+    computed_at: string;
+}
+export interface WorkflowStateReceipt {
+    version: 1;
+    skill: CanonicalJwcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    state_path: string;
+    storage_path: string;
+    mutated_at: string;
+    fresh_until: string;
+    status: WorkflowStateReceiptStatus;
+    mutation_id: string;
+    verb?: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced?: boolean;
+    paths?: string[];
+    content_sha256?: WorkflowStateContentChecksum;
+}
+export interface AuditEntry {
+    ts: string;
+    skill?: string;
+    category: string;
+    verb: string;
+    owner: WorkflowStateMutationOwner;
+    mutation_id: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced: boolean;
+    paths: string[];
+}
+export declare function workflowModeStateFileName(skill: CanonicalJwcWorkflowSkill): string;
+export declare function workflowStateStoragePath(cwd: string, skill: CanonicalJwcWorkflowSkill, sessionId?: string): string;
+export declare function workflowActiveStatePath(cwd: string, sessionId?: string): string;
+export declare function buildWorkflowStateReceipt(input: {
+    cwd: string;
+    skill: CanonicalJwcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    sessionId?: string;
+    nowIso?: string;
+    mutationId?: string;
+}): WorkflowStateReceipt;
+export declare function workflowReceiptStatus(receipt: WorkflowStateReceipt | undefined, nowMs?: number): WorkflowStateReceiptStatus | undefined;
+export declare function canonicalWorkflowSkill(value: string): CanonicalJwcWorkflowSkill | null;
+export declare function sanctionedWorkflowStateCommand(skill: CanonicalJwcWorkflowSkill): string;
+export declare function describeWorkflowStateContract(skill: CanonicalJwcWorkflowSkill): string[];

package/dist/types/skill-state/workflow-state-version.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_VERSION = 2;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -0,0 +1,18 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+export type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * Commands advertised to ACP clients. Entries without a text-mode `handle`
+ * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't
+ * see commands it cannot drive.
+ */
+export declare const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[];
+/**
+ * Dispatch a slash command in ACP/text mode. Returns:
+ * - `false` when no builtin matched (or matched a TUI-only entry); the caller
+ *   should forward the input as a prompt.
+ * - `{ consumed: true }` when the command handled the input entirely.
+ * - `{ prompt }` when the command was handled but a residual prompt should be
+ *   sent to the model.
+ */
+export declare function executeAcpBuiltinSlashCommand(text: string, runtime: AcpBuiltinCommandRuntime): Promise<AcpBuiltinSlashCommandResult>;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -0,0 +1,24 @@
+import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
+export type { BuiltinSlashCommand, SubcommandDef } from "./types";
+/** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export declare function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined;
+/** Builtin command metadata used for slash-command autocomplete and help text. */
+export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;
+/**
+ * Unified registry exposed for cross-mode tooling. Each spec carries at least
+ * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the
+ * ACP dispatcher requires `handle` and skips TUI-only entries.
+ */
+export declare const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommandSpec>;
+/**
+ * Execute a builtin slash command in the interactive TUI.
+ *
+ * Returns `false` when no builtin matched. Returns `true` when a command
+ * consumed the input entirely. Returns a `string` when the command was handled
+ * but remaining text should be sent as a prompt.
+ */
+export declare function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<string | boolean>;
+/** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
+export declare function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined;
+export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };

package/dist/types/slash-commands/helpers/context-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/context` ACP-mode text. Tries the rich breakdown first
+ * (categories + auto-compact buffer + free slack) and falls back to the
+ * minimal "window/used" lines when the breakdown helper throws.
+ */
+export declare function buildContextReportText(runtime: SlashCommandRuntime): string;

package/dist/types/slash-commands/helpers/format.d.ts

@@ -0,0 +1,10 @@
+import { type Theme } from "../../modes/theme/theme";
+/** Format a millisecond duration as a coarse-grained human label. */
+export declare function formatDuration(ms: number): string;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
+/**
+ * Render an ASCII progress bar with a trailing percent label.
+ * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
+ */
+export declare function renderAsciiBar(fraction: number | undefined, width?: number, uiTheme?: ProgressBarTheme): string;
+export {};

package/dist/types/slash-commands/helpers/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/mcp` handler. Shared by both dispatchers via the spec. */
+export declare function handleMcpAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/parse.d.ts

@@ -0,0 +1,33 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+export interface ParsedSubcommand {
+    verb: string;
+    rest: string;
+}
+export type ConfigScope = "user" | "project";
+export interface NamedScopeArgs {
+    name?: string;
+    scope: ConfigScope;
+    error?: string;
+}
+/**
+ * Parse a slash-invocation string into `name`/`args`.
+ *
+ * The separator is the earliest whitespace or `:` character so that both
+ * `/foo bar` and `/foo:bar` map to `{ name: "foo", args: "bar" }`.
+ */
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+/** Mark a command as fully consumed in the ACP shape. */
+export declare function commandConsumed(): {
+    consumed: true;
+};
+/** Emit a usage/error message and consume the command. */
+export declare function usage(text: string, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;
+/** Split `<verb> <rest>` on the first whitespace; lowercases `verb`. */
+export declare function parseSubcommand(input: string): ParsedSubcommand;
+export declare function errorMessage(error: unknown): string;
+/**
+ * Parse `<name?> [--scope project|user]`-style argument strings used by
+ * remove/rm-style subcommands. `name` is optional so callers can surface
+ * "name required" diagnostics with their own messaging.
+ */
+export declare function parseNamedScopeArgs(rest: string, invalidScopeMessage: string): NamedScopeArgs;

package/dist/types/slash-commands/helpers/ssh.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/ssh` handler. Shared by both dispatchers via the spec. */
+export declare function handleSshAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/todo.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/todo` handler. Shared by both dispatchers via the spec. */
+export declare function handleTodoAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/usage-report.d.ts

@@ -0,0 +1,11 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/quota` ACP-mode text for a single OAuth provider.
+ */
+export declare function buildQuotaText(runtime: SlashCommandRuntime, providerId: string): Promise<string>;
+/**
+ * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
+ * session exposes `fetchUsageReports`; otherwise falls back to the local
+ * session-manager tallies.
+ */
+export declare function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string>;

package/dist/types/slash-commands/types.d.ts

@@ -0,0 +1,120 @@
+import type { Settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession } from "../session/agent-session";
+import type { SessionManager } from "../session/session-manager";
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+    name: string;
+    description: string;
+    /** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+    usage?: string;
+}
+/** Declarative builtin slash command metadata used by autocomplete and help UI. */
+export interface BuiltinSlashCommand {
+    name: string;
+    description: string;
+    /** Alternate names that dispatch to the same command (surfaced as separate autocomplete entries). */
+    aliases?: readonly string[];
+    /** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
+    subcommands?: SubcommandDef[];
+    /** Static inline hint when command takes a simple argument (no subcommands). */
+    inlineHint?: string;
+}
+/** Parsed slash-command text after stripping the leading "/". */
+export interface ParsedSlashCommand {
+    name: string;
+    args: string;
+    text: string;
+}
+/**
+ * Result returned by a slash-command handler.
+ *
+ * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ prompt: string }` — command handled, pass `prompt` through as the new
+ *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
+ */
+export type SlashCommandResult = undefined | {
+    consumed: true;
+} | {
+    prompt: string;
+};
+/**
+ * Runtime visible to slash-command handlers that run in text/ACP mode.
+ *
+ * Both the TUI dispatcher (when invoking a `handle` via its adapter) and the
+ * ACP dispatcher pass this shape. Implementations MUST NOT depend on TUI-only
+ * state (editor, selectors, status line).
+ */
+export interface SlashCommandRuntime {
+    session: AgentSession;
+    sessionManager: SessionManager;
+    settings: Settings;
+    cwd: string;
+    /** Emit text to the operator. TUI maps to `ctx.showStatus`, ACP to `sessionUpdate`. */
+    output: (text: string) => Promise<void> | void;
+    /** Re-advertise the available command list (no-op outside ACP). */
+    refreshCommands: () => Promise<void> | void;
+    /**
+     * Reload plugin state (caches, slash command registry, project registries)
+     * and re-emit available commands. `/move` uses this so the session sees a
+     * consistent view after project-scope changes.
+     */
+    reloadPlugins: () => Promise<void>;
+    notifyTitleChanged?: () => Promise<void> | void;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+/**
+ * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
+ * mode context plus the background-detach hook. Intentionally narrower than
+ * `SlashCommandRuntime` so existing callers can keep building it from just
+ * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
+ * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
+ * from `ctx`.
+ */
+export interface TuiSlashCommandRuntime {
+    ctx: InteractiveModeContext;
+    handleBackgroundCommand: () => void;
+}
+/** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
+export interface SlashCommandSpec extends BuiltinSlashCommand {
+    aliases?: string[];
+    /** When false, the dispatcher refuses to handle invocations that include arguments. */
+    allowArgs?: boolean;
+    /**
+     * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
+     * when building `available_commands_update` payloads so the client receives
+     * mode-appropriate copy (e.g. `/dump` advertises "Return full transcript as
+     * plain text" in ACP rather than the TUI's clipboard-centric copy).
+     */
+    acpDescription?: string;
+    /**
+     * ACP-specific override for the advertised input hint. `subcommands`-only
+     * specs that historically advertised `<subcommand>` / `[on|off|status]` /
+     * `info|delete` to ACP clients carry the hint here so the unification does
+     * not silently drop it from `available_commands_update`.
+     */
+    acpInputHint?: string;
+    /**
+     * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
+     * and, via the TUI adapter, when no `handleTui` override is provided.
+     */
+    handle?: (command: ParsedSlashCommand, runtime: SlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+    /**
+     * TUI-only handler that supersedes `handle` when both are present. Use for
+     * selectors, wizards, dashboards, and anything else that requires
+     * `InteractiveModeContext`.
+     */
+    handleTui?: (command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+}
+/**
+ * @deprecated Use `SlashCommandRuntime` directly. Retained as an alias so
+ * downstream code that imported the ACP-specific name keeps compiling.
+ */
+export type AcpBuiltinCommandRuntime = SlashCommandRuntime;
+/** Result returned by `executeAcpBuiltinSlashCommand`. */
+export type AcpBuiltinSlashCommandResult = false | {
+    consumed: true;
+} | {
+    prompt: string;
+};

package/dist/types/ssh/config-writer.d.ts

@@ -0,0 +1,49 @@
+export interface SSHHostConfig {
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    description?: string;
+    compat?: boolean;
+}
+export interface SSHConfigFile {
+    hosts?: Record<string, SSHHostConfig>;
+}
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readSSHConfigFile(filePath: string): Promise<SSHConfigFile>;
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void>;
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateHostName(name: string): string | undefined;
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export declare function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export declare function removeSSHHost(filePath: string, name: string): Promise<void>;
+/**
+ * List all host names in a config file.
+ */
+export declare function listSSHHosts(filePath: string): Promise<string[]>;

package/dist/types/ssh/connection-manager.d.ts

@@ -0,0 +1,33 @@
+export interface SSHConnectionTarget {
+    name: string;
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    compat?: boolean;
+}
+export type SSHHostOs = "windows" | "linux" | "macos" | "unknown";
+export type SSHHostShell = "cmd" | "powershell" | "bash" | "zsh" | "sh" | "unknown";
+export type SshPlatform = typeof process.platform;
+export declare function supportsSshControlMaster(platform?: SshPlatform): boolean;
+export interface SSHHostInfo {
+    version: number;
+    os: SSHHostOs;
+    shell: SSHHostShell;
+    compatShell?: "bash" | "sh";
+    compatEnabled: boolean;
+}
+interface SSHArgsOptions {
+    platform?: SshPlatform;
+}
+export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
+export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;
+export declare function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo>;
+export declare function buildRemoteCommand(host: SSHConnectionTarget, command: string, options?: SSHArgsOptions): Promise<string[]>;
+export declare function ensureConnection(host: SSHConnectionTarget): Promise<void>;
+export declare function invalidateHostMetadata(hostNames: Iterable<string>): Promise<void>;
+export declare function closeConnection(hostName: string): Promise<void>;
+export declare function closeAllConnections(): Promise<void>;
+export declare function getControlPathTemplate(): string;
+export declare function getControlDir(): string;
+export {};

package/dist/types/ssh/ssh-executor.d.ts

@@ -0,0 +1,37 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export interface SSHExecutorOptions {
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Callback for streaming output chunks (already sanitized) */
+    onChunk?: (chunk: string) => void;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Remote path to mount when sshfs is available */
+    remotePath?: string;
+    /** Wrap commands in a POSIX shell for compat mode */
+    compatEnabled?: boolean;
+    /** Artifact path/id for full output storage */
+    artifactPath?: string;
+    artifactId?: string;
+}
+export interface SSHResult {
+    /** Combined stdout + stderr output (sanitized, possibly truncated) */
+    output: string;
+    /** Process exit code (undefined if killed/cancelled) */
+    exitCode: number | undefined;
+    /** Whether the command was cancelled via signal */
+    cancelled: boolean;
+    /** Whether the output was truncated */
+    truncated: boolean;
+    /** Total number of lines in the output stream */
+    totalLines: number;
+    /** Total number of bytes in the output stream */
+    totalBytes: number;
+    /** Number of lines included in the output text */
+    outputLines: number;
+    /** Number of bytes included in the output text */
+    outputBytes: number;
+    /** Artifact ID if full output was saved to artifact storage */
+    artifactId?: string;
+}
+export declare function executeSSH(host: SSHConnectionTarget, command: string, options?: SSHExecutorOptions): Promise<SSHResult>;

package/dist/types/ssh/sshfs-mount.d.ts

@@ -0,0 +1,6 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export declare function hasSshfs(): boolean;
+export declare function isMounted(path: string): Promise<boolean>;
+export declare function mountRemote(host: SSHConnectionTarget, remotePath?: string): Promise<string | undefined>;
+export declare function unmountRemote(host: SSHConnectionTarget): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;

package/dist/types/ssh/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeHostName(name: string): string;
+export declare function buildSshTarget(username: string | undefined, host: string): string;

package/dist/types/stt/downloader.d.ts

@@ -0,0 +1,9 @@
+export interface DownloadProgress {
+    stage: string;
+    percent?: number;
+}
+export interface EnsureOptions {
+    modelName?: string;
+    onProgress?: (progress: DownloadProgress) => void;
+}
+export declare function ensureSTTDependencies(options?: EnsureOptions): Promise<void>;

package/dist/types/stt/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./downloader";
+export * from "./setup";
+export * from "./stt-controller";

package/dist/types/stt/recorder.d.ts

@@ -0,0 +1,13 @@
+export interface RecordingHandle {
+    stop(): Promise<void>;
+}
+/**
+ * Returns available recording tools in priority order.
+ */
+export declare function detectRecordingTools(): string[];
+export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
+/**
+ * Verify a recorded audio file is usable.
+ * Returns the file size in bytes, or throws.
+ */
+export declare function verifyRecordingFile(filePath: string): Promise<number>;

package/dist/types/stt/setup.d.ts

@@ -0,0 +1,18 @@
+export interface STTDependencyStatus {
+    recorder: {
+        available: boolean;
+        tool: string | null;
+        installHint: string;
+    };
+    python: {
+        available: boolean;
+        path: string | null;
+        installHint: string;
+    };
+    whisper: {
+        available: boolean;
+        installHint: string;
+    };
+}
+export declare function checkDependencies(): Promise<STTDependencyStatus>;
+export declare function formatDependencyStatus(status: STTDependencyStatus): string;

package/dist/types/stt/stt-controller.d.ts

@@ -0,0 +1,16 @@
+export type SttState = "idle" | "recording" | "transcribing";
+interface ToggleOptions {
+    showWarning(msg: string): void;
+    showStatus(msg: string): void;
+    onStateChange(state: SttState): void;
+}
+interface Editor {
+    insertText(text: string): void;
+}
+export declare class STTController {
+    #private;
+    get state(): SttState;
+    toggle(editor: Editor, options: ToggleOptions): Promise<void>;
+    dispose(): void;
+}
+export {};

package/dist/types/stt/transcriber.d.ts

@@ -0,0 +1,16 @@
+export interface TranscribeOptions {
+    modelName?: string;
+    language?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Find a usable Python command.
+ */
+export declare function resolvePython(): string | null;
+/**
+ * Transcribe a WAV file using Python openai-whisper.
+ *
+ * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
+ * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ */
+export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/system-prompt.d.ts

@@ -0,0 +1,100 @@
+/**
+ * System prompt construction and project context loading
+ */
+import type { AgentTool } from "@jawcode-dev/agent-core";
+import { type SkillsSettings } from "./config/settings";
+import { type Skill } from "./extensibility/skills";
+import { type WorkspaceTree } from "./workspace-tree";
+interface AlwaysApplyRule {
+    name: string;
+    content: string;
+    path: string;
+}
+/** Resolve input as file path or literal string */
+export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
+export interface LoadContextFilesOptions {
+    /** Working directory to start walking up from. Default: getProjectDir() */
+    cwd?: string;
+}
+/**
+ * Load all project context files using the capability API.
+ * Returns {path, content, depth} entries for all discovered context files.
+ * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ */
+export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Render the agent identity block from `identity.*` settings (name, emoji,
+ * vibe, language). Returns null when no field is set or when the settings
+ * singleton is not initialized (bare SDK/embedding paths), so the hard-edited
+ * Jaw baseline prompt is used unchanged.
+ */
+export declare function renderIdentityBlock(): string | null;
+/**
+ * Load the effective system prompt customization from SYSTEM.md.
+ * Project-level SYSTEM.md overrides user-level SYSTEM.md.
+ */
+export declare function loadSystemPromptFiles(options?: LoadContextFilesOptions): Promise<string | null>;
+export interface SystemPromptToolMetadata {
+    label: string;
+    description: string;
+    /** Tool name the model sees on the provider wire. Defaults to the internal tool name. */
+    wireName?: string;
+}
+export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTool>, overrides?: Partial<Record<string, Partial<SystemPromptToolMetadata>>>): Map<string, SystemPromptToolMetadata>;
+export interface BuildSystemPromptOptions {
+    /** Custom system prompt (replaces default). */
+    customPrompt?: string;
+    /** Tools to include in prompt. */
+    tools?: Map<string, SystemPromptToolMetadata>;
+    /** Tool names to include in prompt. */
+    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() */
+    cwd?: string;
+    /** Pre-loaded context files (skips discovery if provided). */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+        depth?: number;
+    }>;
+    /** Skills provided directly to system prompt construction. */
+    skills?: Skill[];
+    /** Pre-loaded rulebook rules (descriptions, excluding TTSR and always-apply). */
+    rules?: Array<{
+        name: string;
+        description?: string;
+        path: string;
+        globs?: string[];
+    }>;
+    /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
+    intentField?: string;
+    /** Whether MCP tool discovery is active for this prompt build. */
+    mcpDiscoveryMode?: boolean;
+    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
+    mcpDiscoveryServerSummaries?: string[];
+    /** Encourage the agent to delegate via tasks unless changes are trivial. */
+    eagerTasks?: boolean;
+    /** Rules with alwaysApply=true — their full content is injected into the prompt. */
+    alwaysApplyRules?: AlwaysApplyRule[];
+    /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
+    secretsEnabled?: boolean;
+    /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
+    workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+}
+/** Result of building provider-facing system prompt messages. */
+export interface BuildSystemPromptResult {
+    /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
+    systemPrompt: string[];
+}
+/** Build the system prompt with tools, guidelines, and context */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export {};