@sayknow-cli/coding-agent 0.3.6 → 0.3.7

package/dist/types/autoresearch/tools/init-experiment.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
+export declare const HARNESS_FILENAME = "autoresearch.sh";
+export declare const DEFAULT_HARNESS_COMMAND = "bash autoresearch.sh";
+declare const initExperimentSchema: z.ZodObject<{
+    name: z.ZodString;
+    goal: z.ZodOptional<z.ZodString>;
+    primary_metric: z.ZodString;
+    metric_unit: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        higher: "higher";
+        lower: "lower";
+    }>>;
+    secondary_metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    scope_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    off_limits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNumber>;
+    new_segment: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+interface InitExperimentDetails {
+    state: ExperimentState;
+    createdSession: boolean;
+    bumpedSegment: boolean;
+    abandonedRuns: number;
+    harnessCommitted: boolean;
+    baselineCommit: string | null;
+}
+export declare function createInitExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof initExperimentSchema, InitExperimentDetails>;
+export {};

package/dist/types/autoresearch/tools/log-experiment.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, LogDetails } from "../types";
+declare const logExperimentSchema: z.ZodObject<{
+    metric: z.ZodNumber;
+    status: z.ZodEnum<{
+        checks_failed: "checks_failed";
+        crash: "crash";
+        discard: "discard";
+        keep: "keep";
+    }>;
+    description: z.ZodString;
+    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    asi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    commit: z.ZodOptional<z.ZodString>;
+    justification: z.ZodOptional<z.ZodString>;
+    flag_runs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        run_id: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function createLogExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof logExperimentSchema, LogDetails>;
+export {};

package/dist/types/autoresearch/tools/run-experiment.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod/v4";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
+declare const runExperimentSchema: z.ZodObject<{
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createRunExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof runExperimentSchema, RunDetails | RunExperimentProgressDetails>;
+export {};

package/dist/types/autoresearch/tools/update-notes.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions } from "../types";
+declare const updateNotesSchema: z.ZodObject<{
+    body: z.ZodString;
+    append_idea: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface UpdateNotesDetails {
+    notes: string;
+}
+export declare function createUpdateNotesTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof updateNotesSchema, UpdateNotesDetails>;
+export {};

package/dist/types/autoresearch/types.d.ts

@@ -0,0 +1,154 @@
+import type { AgentToolResult } from "@sayknow-cli/agent-core";
+import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
+import type { SessionEntry } from "../session/session-manager";
+import type { TruncationResult } from "../session/streaming-output";
+export type MetricDirection = "lower" | "higher";
+export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
+export type ASIValue = string | number | boolean | null | ASIValue[] | {
+    [key: string]: ASIValue;
+};
+export interface ASIData {
+    [key: string]: ASIValue;
+}
+export interface NumericMetricMap {
+    [key: string]: number;
+}
+export interface MetricDef {
+    name: string;
+    unit: string;
+}
+export interface ExperimentResult {
+    runNumber: number | null;
+    commit: string;
+    metric: number;
+    metrics: NumericMetricMap;
+    status: ExperimentStatus;
+    description: string;
+    timestamp: number;
+    segment: number;
+    confidence: number | null;
+    asi?: ASIData;
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+}
+export interface ExperimentState {
+    results: ExperimentResult[];
+    bestMetric: number | null;
+    bestDirection: MetricDirection;
+    metricName: string;
+    metricUnit: string;
+    secondaryMetrics: MetricDef[];
+    name: string | null;
+    goal: string | null;
+    currentSegment: number;
+    maxExperiments: number | null;
+    confidence: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    notes: string;
+    branch: string | null;
+    baselineCommit: string | null;
+    sessionId: number | null;
+}
+export interface RunExperimentProgressDetails {
+    phase: "running";
+    elapsed: string;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+    runDirectory?: string;
+}
+export interface RunDetails {
+    runNumber: number;
+    runDirectory: string;
+    benchmarkLogPath: string;
+    command: string;
+    exitCode: number | null;
+    durationSeconds: number;
+    passed: boolean;
+    crashed: boolean;
+    timedOut: boolean;
+    tailOutput: string;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    parsedAsi: ASIData | null;
+    metricName: string;
+    metricUnit: string;
+    preRunDirtyPaths: string[];
+    abandonedPriorRun: number | null;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+export interface LogDetails {
+    experiment: ExperimentResult;
+    state: ExperimentState;
+    wallClockSeconds: number | null;
+    scopeDeviations: string[];
+    justification: string | null;
+    flaggedRuns: Array<{
+        runId: number;
+        reason: string;
+    }>;
+}
+export interface PendingRunSummary {
+    command: string;
+    durationSeconds: number | null;
+    parsedAsi: ASIData | null;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    passed: boolean;
+    preRunDirtyPaths: string[];
+    runDirectory: string;
+    runNumber: number;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export interface RunningExperiment {
+    startedAt: number;
+    command: string;
+    runDirectory: string;
+    runNumber: number;
+}
+export interface AutoresearchRuntime {
+    autoresearchMode: boolean;
+    autoResumeArmed: boolean;
+    dashboardExpanded: boolean;
+    lastAutoResumePendingRunNumber: number | null;
+    lastRunDuration: number | null;
+    lastRunAsi: ASIData | null;
+    lastRunArtifactDir: string | null;
+    lastRunNumber: number | null;
+    lastRunSummary: PendingRunSummary | null;
+    runningExperiment: RunningExperiment | null;
+    state: ExperimentState;
+    goal: string | null;
+}
+export interface AutoresearchControlEntryData {
+    mode: "on" | "off" | "clear";
+    goal?: string;
+}
+export interface ReconstructedControlState {
+    autoresearchMode: boolean;
+    goal: string | null;
+    lastMode: AutoresearchControlEntryData["mode"] | null;
+}
+export interface RuntimeStore {
+    clear(sessionKey: string): void;
+    ensure(sessionKey: string): AutoresearchRuntime;
+}
+export interface DashboardController {
+    clear(ctx: ExtensionContext): void;
+    requestRender(): void;
+    showOverlay(ctx: ExtensionContext, runtime: AutoresearchRuntime): Promise<void>;
+    updateWidget(ctx: ExtensionContext, runtime: AutoresearchRuntime): void;
+}
+export interface AutoresearchToolFactoryOptions {
+    dashboard: DashboardController;
+    getRuntime(ctx: ExtensionContext): AutoresearchRuntime;
+    pi: ExtensionAPI;
+}
+export type AutoresearchToolResult<TDetails> = AgentToolResult<TDetails>;
+export type SessionEntries = SessionEntry[];

package/dist/types/capability/context-file.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * A context file that provides persistent instructions to the agent.
+ */
+export interface ContextFile {
+    /** Absolute path to the file */
+    path: string;
+    /** File content */
+    content: string;
+    /** Which level this came from */
+    level: "user" | "project";
+    /** Distance from cwd (0 = in cwd, 1 = parent, etc.) for project files */
+    depth?: number;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const contextFileCapability: import("./types").Capability<ContextFile>;

package/dist/types/capability/extension-module.d.ts

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A loaded extension module.
+ */
+export interface ExtensionModule {
+    /** Extension module name (derived from path) */
+    name: string;
+    /** Absolute path to extension entrypoint */
+    path: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const extensionModuleCapability: import("./types").Capability<ExtensionModule>;

package/dist/types/capability/extension.d.ts

@@ -0,0 +1,28 @@
+import type { MCPServer } from "./mcp";
+import type { SourceMeta } from "./types";
+/**
+ * Extension manifest structure.
+ */
+export interface ExtensionManifest {
+    name?: string;
+    description?: string;
+    mcpServers?: Record<string, Omit<MCPServer, "name" | "_source">>;
+    tools?: unknown[];
+    context?: unknown;
+}
+/**
+ * A loaded extension.
+ */
+export interface Extension {
+    /** Extension name (from manifest.name or directory name) */
+    name: string;
+    /** Absolute path to extension directory */
+    path: string;
+    /** Parsed manifest data */
+    manifest: ExtensionManifest;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const extensionCapability: import("./types").Capability<Extension>;

package/dist/types/capability/fs.d.ts

@@ -0,0 +1,20 @@
+import * as fs from "node:fs";
+export declare function readFile(filePath: string): Promise<string | null>;
+export declare function readDirEntries(dirPath: string): Promise<fs.Dirent[]>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+export declare function walkUp(startDir: string, name: string, opts?: {
+    file?: boolean;
+    dir?: boolean;
+}): Promise<string | null>;
+/**
+ * Walk up from startDir looking for a `.git` entry (file or directory).
+ * Returns the directory containing `.git` (the repo root), or null if not in a git repo.
+ * Results are based on the cached readDirEntries, so repeated calls are cheap.
+ */
+export declare function findRepoRoot(startDir: string): Promise<string | null>;
+export declare function cacheStats(): {
+    content: number;
+    dir: number;
+};
+export declare function clearCache(): void;
+export declare function invalidate(filePath: string): void;

package/dist/types/capability/hook.d.ts

@@ -0,0 +1,19 @@
+import type { SourceMeta } from "./types";
+/**
+ * A hook script.
+ */
+export interface Hook {
+    /** Hook name (filename without extension) */
+    name: string;
+    /** Absolute path to hook file */
+    path: string;
+    /** Hook type (pre/post) and associated tool */
+    type: "pre" | "post";
+    /** Tool this hook applies to, or "*" for all */
+    tool: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const hookCapability: import("./types").Capability<Hook>;

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

@@ -0,0 +1,80 @@
+import type { Settings } from "../config/settings";
+import type { Capability, CapabilityInfo, CapabilityResult, LoadOptions, Provider, ProviderInfo } from "./types";
+/**
+ * Define a new capability.
+ */
+export declare function defineCapability<T>(def: Omit<Capability<T>, "providers">): Capability<T>;
+/**
+ * Register a provider for a capability.
+ */
+export declare function registerProvider<T>(capabilityId: string, provider: Provider<T>): void;
+/**
+ * Load a capability by ID.
+ */
+export declare function loadCapability<T>(capabilityId: string, options?: LoadOptions): Promise<CapabilityResult<T>>;
+/**
+ * Initialize capability system with settings manager for persistence.
+ * Call this once on startup to enable persistent provider state.
+ */
+export declare function initializeWithSettings(activeSettings: Settings): void;
+/**
+ * Disable a provider globally (across all capabilities).
+ */
+export declare function disableProvider(providerId: string): void;
+/**
+ * Enable a previously disabled provider.
+ */
+export declare function enableProvider(providerId: string): void;
+/**
+ * Check if a provider is enabled.
+ */
+export declare function isProviderEnabled(providerId: string): boolean;
+/**
+ * Get list of all disabled provider IDs.
+ */
+export declare function getDisabledProviders(): string[];
+/**
+ * Set disabled providers from a list (replaces current set).
+ */
+export declare function setDisabledProviders(providerIds: string[]): void;
+/**
+ * Get a capability definition (for introspection).
+ */
+export declare function getCapability<T>(id: string): Capability<T> | undefined;
+/**
+ * List all registered capability IDs.
+ */
+export declare function listCapabilities(): string[];
+/**
+ * Get capability info for UI display.
+ */
+export declare function getCapabilityInfo(capabilityId: string): CapabilityInfo | undefined;
+/**
+ * Get all capabilities info for UI display.
+ */
+export declare function getAllCapabilitiesInfo(): CapabilityInfo[];
+/**
+ * Get provider info for UI display.
+ */
+export declare function getProviderInfo(providerId: string): ProviderInfo | undefined;
+/**
+ * Get all providers info for UI display (deduplicated across capabilities).
+ */
+export declare function getAllProvidersInfo(): ProviderInfo[];
+/**
+ * Reset all caches. Call after chdir or filesystem changes.
+ */
+export declare function reset(): void;
+/**
+ * Invalidate cache for a specific path.
+ * @param filePath - Absolute or relative path to invalidate
+ */
+export declare function invalidate(filePath: string, cwd?: string): void;
+/**
+ * Get cache stats for diagnostics.
+ */
+export declare function cacheStats(): {
+    content: number;
+    dir: number;
+};
+export type * from "./types";

package/dist/types/capability/instruction.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * An instruction with optional file pattern matching.
+ */
+export interface Instruction {
+    /** Instruction name (derived from filename) */
+    name: string;
+    /** Absolute path to instruction file */
+    path: string;
+    /** Instruction content (markdown) */
+    content: string;
+    /** Glob pattern for files this applies to */
+    applyTo?: string;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const instructionCapability: import("./types").Capability<Instruction>;

package/dist/types/capability/mcp.d.ts

@@ -0,0 +1,47 @@
+import type { SourceMeta } from "./types";
+/**
+ * Canonical MCP server configuration.
+ */
+export interface MCPServer {
+    /** Server name (unique key) */
+    name: string;
+    /** Whether this server is enabled (default: true) */
+    enabled?: boolean;
+    /** Whether to connect automatically at session startup (default: true) */
+    autoload?: boolean;
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Command to run (for stdio transport) */
+    command?: string;
+    /** Command arguments */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory for stdio transport */
+    cwd?: string;
+    /** URL (for HTTP/SSE transport) */
+    url?: string;
+    /** HTTP headers (for HTTP transport) */
+    headers?: Record<string, string>;
+    /** Authentication configuration */
+    auth?: {
+        type: "oauth" | "apikey";
+        credentialId?: string;
+        tokenUrl?: string;
+        clientId?: string;
+        clientSecret?: string;
+    };
+    /** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath) for servers requiring explicit client credentials */
+    oauth?: {
+        clientId?: string;
+        clientSecret?: string;
+        redirectUri?: string;
+        callbackPort?: number;
+        callbackPath?: string;
+    };
+    /** Transport type */
+    transport?: "stdio" | "sse" | "http";
+    /** Source metadata (added by loader) */
+    _source: SourceMeta;
+}
+export declare const mcpCapability: import("./types").Capability<MCPServer>;

package/dist/types/capability/prompt.d.ts

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A reusable prompt template.
+ */
+export interface Prompt {
+    /** Prompt name (filename without extension) */
+    name: string;
+    /** Absolute path to prompt file */
+    path: string;
+    /** Prompt content (markdown) */
+    content: string;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const promptCapability: import("./types").Capability<Prompt>;

package/dist/types/capability/rule.d.ts

@@ -0,0 +1,61 @@
+import type { SourceMeta } from "./types";
+/**
+ * Parsed frontmatter from rule files.
+ */
+export interface RuleFrontmatter {
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+    /** New key for TTSR match conditions. */
+    condition?: string | string[];
+    /** New key for TTSR stream scope. */
+    scope?: string | string[];
+    /** Per-rule TTSR interrupt mode override. */
+    interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+    [key: string]: unknown;
+}
+/**
+ * A rule providing project-specific guidance and constraints.
+ */
+export interface Rule {
+    /** Rule name (derived from filename) */
+    name: string;
+    /** Absolute path to rule file */
+    path: string;
+    /** Rule content (after frontmatter stripped) */
+    content: string;
+    /** Globs this rule applies to (if any) */
+    globs?: string[];
+    /** Whether to always include this rule */
+    alwaysApply?: boolean;
+    /** Description (for agent-requested rules) */
+    description?: string;
+    /** Regex condition(s) that can trigger TTSR interruption. */
+    condition?: string[];
+    /** Optional stream scope tokens (for example: text, thinking, tool:edit(*.ts)). */
+    scope?: string[];
+    /** Per-rule TTSR interrupt mode override (falls back to global ttsr.interruptMode). */
+    interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+/**
+ * Parse `condition` + `scope` from rule frontmatter.
+ *
+ * - `condition` accepts string or string[]
+ * - `scope` accepts string or string[]
+ * - legacy `ttsr_trigger` / `ttsrTrigger` are accepted as a `condition` fallback
+ * - condition tokens that look like file globs become scope shorthands:
+ *   `*.rs` => `tool:edit(*.rs)`, `tool:write(*.rs)` and a catch-all condition `.*`
+ */
+export declare function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<Rule, "condition" | "scope">;
+/**
+ * Process-global snapshot of rules the active session loaded.
+ * Read by internal URL protocol handlers (rule://).
+ */
+export declare function getActiveRules(): readonly Rule[];
+/** Replace the active rule snapshot. Called once per top-level session. */
+export declare function setActiveRules(value: readonly Rule[]): void;
+/** Reset the active rule snapshot. Test-only. */
+export declare function resetActiveRulesForTests(): void;
+export declare const ruleCapability: import("./types").Capability<Rule>;

package/dist/types/capability/settings.d.ts

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A settings file.
+ */
+export interface Settings {
+    /** Absolute path to settings file */
+    path: string;
+    /** Parsed settings data */
+    data: Record<string, unknown>;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const settingsCapability: import("./types").Capability<Settings>;

package/dist/types/capability/skill.d.ts

@@ -0,0 +1,36 @@
+import type { SourceMeta } from "./types";
+/**
+ * Parsed frontmatter from a skill file.
+ */
+export interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+    /**
+     * When `true`, the skill is loaded and accessible via `skill://<name>` (and
+     * `/skill:<name>` slash commands), but is omitted from the rendered system
+     * prompt's skill listing. Use for skills the user opts into explicitly
+     * rather than ones the model should auto-discover.
+     */
+    hide?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * A skill that provides specialized knowledge or workflows.
+ */
+export interface Skill {
+    /** Skill name (unique key, derived from filename or frontmatter) */
+    name: string;
+    /** Absolute path to skill file */
+    path: string;
+    /** Skill content (markdown) */
+    content: string;
+    /** Parsed frontmatter */
+    frontmatter?: SkillFrontmatter;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const skillCapability: import("./types").Capability<Skill>;

package/dist/types/capability/slash-command.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * A file-based slash command.
+ */
+export interface SlashCommand {
+    /** Command name (without leading slash) */
+    name: string;
+    /** Absolute path to command file */
+    path: string;
+    /** Command content (markdown template) */
+    content: string;
+    /** Source level */
+    level: "user" | "project" | "native";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const slashCommandCapability: import("./types").Capability<SlashCommand>;

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

@@ -0,0 +1,23 @@
+import type { SourceMeta } from "./types";
+/**
+ * Canonical SSH host entry.
+ */
+export interface SSHHost {
+    /** Host name (config key) */
+    name: string;
+    /** Host address or DNS name */
+    host: string;
+    /** Optional username override */
+    username?: string;
+    /** Optional port override */
+    port?: number;
+    /** Optional identity key path */
+    keyPath?: string;
+    /** Optional host description */
+    description?: string;
+    /** Optional compatibility mode flag */
+    compat?: boolean;
+    /** Source metadata (added by loader) */
+    _source: SourceMeta;
+}
+export declare const sshCapability: import("./types").Capability<SSHHost>;

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

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A system prompt customization file.
+ */
+export interface SystemPrompt {
+    /** Absolute path to the file */
+    path: string;
+    /** File content */
+    content: string;
+    /** Which level this came from */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const systemPromptCapability: import("./types").Capability<SystemPrompt>;