opencode-swarm 6.6.1 → 6.8.0

package/dist/plan/manager.d.ts

@@ -6,11 +6,17 @@ import { type Plan, type TaskStatus } from '../config/plan-schema';
  */
 export declare function loadPlanJsonOnly(directory: string): Promise<Plan | null>;
 /**
- * Load and validate plan from .swarm/plan.json with 4-step precedence:
- * 1. .swarm/plan.json exists AND validates → return parsed Plan
- * 2. .swarm/plan.json exists but FAILS validation → log warning, fall to step 3
- * 3. .swarm/plan.md exists → call migrateLegacyPlan(), save result, return it
- * 4. Neither exists → return null
+ * Load and validate plan from .swarm/plan.json with auto-heal sync.
+ *
+ * 4-step precedence with auto-heal:
+ * 1. .swarm/plan.json exists AND validates ->
+ *    a) If plan.md missing or stale -> regenerate plan.md from plan.json
+ *    b) Return parsed Plan
+ * 2. .swarm/plan.json exists but FAILS validation ->
+ *    a) If plan.md exists -> migrate from plan.md, save valid plan.json, then derive plan.md
+ *    b) Return migrated Plan
+ * 3. .swarm/plan.md exists only -> migrate from plan.md, save both files, return Plan
+ * 4. Neither exists -> return null
  */
 export declare function loadPlan(directory: string): Promise<Plan | null>;
 /**
@@ -24,7 +30,8 @@ export declare function savePlan(directory: string, plan: Plan): Promise<void>;
  */
 export declare function updateTaskStatus(directory: string, taskId: string, status: TaskStatus): Promise<Plan>;
 /**
- * Generate markdown view from plan object
+ * Generate deterministic markdown view from plan object.
+ * Ensures stable ordering: phases by ID (ascending), tasks by ID (natural numeric).
  */
 export declare function derivePlanMarkdown(plan: Plan): string;
 /**

package/dist/services/config-doctor.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Config Doctor Service
+ *
+ * Validates opencode-swarm config shape, detects stale/invalid settings,
+ * classifies findings by severity, and proposes safe auto-fixes.
+ */
+import type { PluginConfig } from '../config/schema';
+/** Severity levels for config findings */
+export type FindingSeverity = 'info' | 'warn' | 'error';
+/** A single config finding */
+export interface ConfigFinding {
+    /** Unique identifier for this finding type */
+    id: string;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Severity level */
+    severity: FindingSeverity;
+    /** Path to the config key (dot notation) */
+    path: string;
+    /** Current invalid/stale value */
+    currentValue?: unknown;
+    /** Proposed safe fix (if available) */
+    proposedFix?: ConfigFix;
+    /** Whether this is auto-fixable (safe, non-destructive) */
+    autoFixable: boolean;
+}
+/** A proposed config fix */
+export interface ConfigFix {
+    /** Type of fix */
+    type: 'remove' | 'update' | 'add';
+    /** Path to the config key (dot notation) */
+    path: string;
+    /** Value to set (for update/add) */
+    value?: unknown;
+    /** Description of what the fix does */
+    description: string;
+    /** Risk level - only 'low' is auto-fixable */
+    risk: 'low' | 'medium' | 'high';
+}
+/** Result of running the config doctor */
+export interface ConfigDoctorResult {
+    /** All findings from the doctor run */
+    findings: ConfigFinding[];
+    /** Findings by severity */
+    summary: {
+        info: number;
+        warn: number;
+        error: number;
+    };
+    /** Whether any auto-fixable issues were found */
+    hasAutoFixableIssues: boolean;
+    /** Timestamp of the run */
+    timestamp: number;
+    /** The config that was analyzed */
+    configSource: string;
+}
+/** Backup artifact for rollback */
+export interface ConfigBackup {
+    /** When the backup was created */
+    createdAt: number;
+    /** The backed up config content */
+    configPath: string;
+    /** The raw config content */
+    content: string;
+    /** Hash of content for integrity verification */
+    contentHash: string;
+}
+/**
+ * Get config file paths
+ */
+export declare function getConfigPaths(directory: string): {
+    userConfigPath: string;
+    projectConfigPath: string;
+};
+/**
+ * Create a backup of the current config
+ */
+export declare function createConfigBackup(directory: string): ConfigBackup | null;
+/**
+ * Write a backup artifact to .swarm directory
+ * Persists full backup content to support rollback/restore
+ */
+export declare function writeBackupArtifact(directory: string, backup: ConfigBackup): string;
+/**
+ * Restore config from a backup artifact
+ * @param backupPath - Path to the backup artifact file
+ * @param directory - The working directory (for validating config paths)
+ * @returns the path to the restored config file, or null if restore failed
+ */
+export declare function restoreFromBackup(backupPath: string, directory: string): string | null;
+/**
+ * Run the config doctor on a loaded config
+ */
+export declare function runConfigDoctor(config: PluginConfig, directory: string): ConfigDoctorResult;
+/**
+ * Apply safe auto-fixes to config
+ * Only applies low-risk, non-destructive fixes
+ */
+export declare function applySafeAutoFixes(directory: string, result: ConfigDoctorResult): {
+    appliedFixes: ConfigFix[];
+    updatedConfigPath: string | null;
+};
+/**
+ * Write doctor result to .swarm directory for GUI consumption
+ */
+export declare function writeDoctorArtifact(directory: string, result: ConfigDoctorResult): string;
+/**
+ * Check if config doctor should run on startup
+ */
+export declare function shouldRunOnStartup(automationConfig: {
+    mode: string;
+    capabilities?: Record<string, boolean>;
+} | undefined): boolean;
+/**
+ * Full config doctor run with backup and fix application
+ */
+export declare function runConfigDoctorWithFixes(directory: string, config: PluginConfig, autoFix?: boolean): Promise<{
+    result: ConfigDoctorResult;
+    backupPath: string | null;
+    appliedFixes: ConfigFix[];
+    updatedConfigPath: string | null;
+    artifactPath: string | null;
+}>;

package/dist/services/config-doctor.security.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/config-doctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/decision-drift-analyzer.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Decision Drift Analyzer Service
+ *
+ * Analyzes decisions from context.md and current plan state to detect:
+ * 1. Stale decisions (age/phase mismatch or no recent confirmation)
+ * 2. Contradictions (new decisions conflicting with existing ones)
+ *
+ * Results are integrated into architect context injection.
+ */
+/**
+ * Drift signal severity levels
+ */
+export type DriftSeverity = 'warning' | 'error';
+/**
+ * A single decision extracted from context.md
+ */
+export interface Decision {
+    /** Raw decision text */
+    text: string;
+    /** Phase when decision was made (extracted or inferred) */
+    phase: number | null;
+    /** Whether decision has a confirmation marker */
+    confirmed: boolean;
+    /** Timestamp if available */
+    timestamp: string | null;
+    /** Line number in source file */
+    line: number;
+}
+/**
+ * A detected drift signal
+ */
+export interface DriftSignal {
+    /** Unique identifier for this drift */
+    id: string;
+    /** Severity level */
+    severity: DriftSeverity;
+    /** Type of drift */
+    type: 'stale' | 'contradiction';
+    /** Human-readable description */
+    message: string;
+    /** Source reference (file and line) */
+    source: {
+        file: string;
+        line: number;
+    };
+    /** Related decisions if applicable */
+    relatedDecisions?: string[];
+    /** Suggested resolution hint */
+    hint?: string;
+}
+/**
+ * Result of drift analysis
+ */
+export interface DriftAnalysisResult {
+    /** Whether drift was detected */
+    hasDrift: boolean;
+    /** List of drift signals */
+    signals: DriftSignal[];
+    /** Summary text for context injection */
+    summary: string;
+    /** Timestamp of analysis */
+    analyzedAt: string;
+}
+/**
+ * Configuration for drift analyzer
+ */
+export interface DriftAnalyzerConfig {
+    /** Maximum age in phases before a decision is considered stale */
+    staleThresholdPhases: number;
+    /** Whether to detect contradictions */
+    detectContradictions: boolean;
+    /** Maximum signals to return */
+    maxSignals: number;
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_DRIFT_CONFIG: DriftAnalyzerConfig;
+/**
+ * Extract decisions from context.md content
+ */
+export declare function extractDecisionsFromContext(contextContent: string): Decision[];
+/**
+ * Simple keyword-based contradiction detection
+ * Looks for decisions that express opposite intentions
+ */
+export declare function findContradictions(decisions: Decision[]): DriftSignal[];
+/**
+ * Analyze decision drift
+ */
+export declare function analyzeDecisionDrift(directory: string, config?: Partial<DriftAnalyzerConfig>): Promise<DriftAnalysisResult>;
+/**
+ * Format drift signals as a structured section for context injection
+ * Returns bounded output suitable for LLM context
+ */
+export declare function formatDriftForContext(result: DriftAnalysisResult): string;

package/dist/services/diagnose-service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A single health check result.
+ */
+export interface HealthCheck {
+    name: string;
+    status: '✅' | '❌';
+    detail: string;
+}
+/**
+ * Structured diagnose data returned by the diagnose service.
+ */
+export interface DiagnoseData {
+    checks: HealthCheck[];
+    passCount: number;
+    totalCount: number;
+    allPassed: boolean;
+}
+/**
+ * Get diagnose data from the swarm directory.
+ * Returns structured health checks for GUI, background flows, or commands.
+ */
+export declare function getDiagnoseData(directory: string): Promise<DiagnoseData>;
+/**
+ * Format diagnose data as markdown for command output.
+ */
+export declare function formatDiagnoseMarkdown(diagnose: DiagnoseData): string;
+/**
+ * Handle diagnose command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleDiagnoseCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/evidence-service.d.ts

@@ -0,0 +1,65 @@
+import type { Evidence } from '../config/evidence-schema';
+/**
+ * Structured evidence entry for a task.
+ */
+export interface EvidenceEntryData {
+    index: number;
+    entry: Evidence;
+    type: string;
+    verdict: string;
+    verdictIcon: string;
+    agent: string;
+    summary: string;
+    timestamp: string;
+    details: Record<string, string | number | undefined>;
+}
+/**
+ * Structured evidence data for a single task.
+ */
+export interface TaskEvidenceData {
+    hasEvidence: boolean;
+    taskId: string;
+    createdAt: string;
+    updatedAt: string;
+    entries: EvidenceEntryData[];
+}
+/**
+ * Structured evidence list data for all tasks.
+ */
+export interface EvidenceListData {
+    hasEvidence: boolean;
+    tasks: Array<{
+        taskId: string;
+        entryCount: number;
+        lastUpdated: string;
+    }>;
+}
+/**
+ * Get emoji for verdict type (exported for use in entry formatting).
+ */
+export declare function getVerdictEmoji(verdict: string): string;
+/**
+ * Get evidence data for a specific task.
+ */
+export declare function getTaskEvidenceData(directory: string, taskId: string): Promise<TaskEvidenceData>;
+/**
+ * Get list of all evidence bundles.
+ */
+export declare function getEvidenceListData(directory: string): Promise<EvidenceListData>;
+/**
+ * Format evidence list as markdown for command output.
+ */
+export declare function formatEvidenceListMarkdown(list: EvidenceListData): string;
+/**
+ * Format task evidence as markdown for command output.
+ */
+export declare function formatTaskEvidenceMarkdown(evidence: TaskEvidenceData): string;
+/**
+ * Handle evidence command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleEvidenceCommand(directory: string, args: string[]): Promise<string>;
+/**
+ * Handle evidence summary command - generates completion ratio and blockers report.
+ */
+export declare function handleEvidenceSummaryCommand(directory: string): Promise<string>;

package/dist/services/evidence-summary-service.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Evidence Summary Service
+ *
+ * Provides deterministic evidence aggregation per task and phase.
+ * Produces machine-readable and human-readable summary artifacts.
+ */
+import type { PhaseStatus, TaskStatus } from '../config/plan-schema';
+/** Evidence types required for task completion */
+export declare const REQUIRED_EVIDENCE_TYPES: readonly ["review", "test"];
+export type RequiredEvidenceType = (typeof REQUIRED_EVIDENCE_TYPES)[number];
+/** Summary artifact schema version */
+export declare const EVIDENCE_SUMMARY_VERSION = "1.0.0";
+/** Evidence summary for a single task */
+export interface TaskEvidenceSummary {
+    taskId: string;
+    phase: number;
+    taskStatus: TaskStatus;
+    evidenceCount: number;
+    hasReview: boolean;
+    hasTest: boolean;
+    hasApproval: boolean;
+    missingEvidence: string[];
+    isComplete: boolean;
+    blockers: string[];
+    lastEvidenceTimestamp: string | null;
+}
+/** Phase evidence summary */
+export interface PhaseEvidenceSummary {
+    phaseId: number;
+    phaseName: string;
+    phaseStatus: PhaseStatus;
+    totalTasks: number;
+    completedTasks: number;
+    tasksWithEvidence: number;
+    tasksWithCompleteEvidence: number;
+    completionRatio: number;
+    missingEvidenceByType: Record<string, string[]>;
+    blockers: PhaseBlocker[];
+    tasks: TaskEvidenceSummary[];
+}
+/** Blockers preventing phase closure */
+export interface PhaseBlocker {
+    type: 'missing_evidence' | 'incomplete_task' | 'blocked_task';
+    taskId: string;
+    reason: string;
+    severity: 'high' | 'medium' | 'low';
+}
+/** Full evidence summary artifact */
+export interface EvidenceSummaryArtifact {
+    schema_version: typeof EVIDENCE_SUMMARY_VERSION;
+    generated_at: string;
+    planTitle: string;
+    currentPhase: number;
+    phaseSummaries: PhaseEvidenceSummary[];
+    overallCompletionRatio: number;
+    overallBlockers: PhaseBlocker[];
+    summaryText: string;
+}
+/**
+ * Build complete evidence summary artifact
+ *
+ * Aggregates evidence per task and phase, producing deterministic
+ * summary artifacts including completion ratio, missing evidence,
+ * blockers, and per-task status.
+ */
+export declare function buildEvidenceSummary(directory: string, currentPhase?: number): Promise<EvidenceSummaryArtifact | null>;
+/**
+ * Check if auto-summaries are enabled via feature flags
+ */
+export declare function isAutoSummaryEnabled(automationConfig?: {
+    capabilities?: {
+        evidence_auto_summaries?: boolean;
+    };
+    mode?: string;
+}): boolean;

package/dist/services/export-service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Structured export data.
+ */
+export interface ExportData {
+    version: string;
+    exported: string;
+    plan: unknown;
+    context: string | null;
+}
+/**
+ * Get export data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getExportData(directory: string): Promise<ExportData>;
+/**
+ * Format export data as markdown with JSON code block for command output.
+ */
+export declare function formatExportMarkdown(exportData: ExportData): string;
+/**
+ * Handle export command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleExportCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/history-service.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Structured history data for a single phase.
+ */
+export interface PhaseHistoryData {
+    id: number;
+    name: string;
+    status: 'complete' | 'in_progress' | 'pending' | 'blocked';
+    statusText: string;
+    statusIcon: string;
+    completedTasks: number;
+    totalTasks: number;
+    tasksDisplay: string;
+}
+/**
+ * Structured history data returned by the history service.
+ */
+export interface HistoryData {
+    hasPlan: boolean;
+    phases: PhaseHistoryData[];
+    isLegacy: boolean;
+}
+/**
+ * Get history data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getHistoryData(directory: string): Promise<HistoryData>;
+/**
+ * Format history data as markdown for command output.
+ */
+export declare function formatHistoryMarkdown(history: HistoryData): string;
+/**
+ * Handle history command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleHistoryCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/index.d.ts

@@ -0,0 +1,11 @@
+export { analyzeDecisionDrift, DEFAULT_DRIFT_CONFIG, type Decision, type DriftAnalysisResult, type DriftAnalyzerConfig, type DriftSeverity, type DriftSignal, extractDecisionsFromContext, findContradictions, formatDriftForContext, } from './decision-drift-analyzer';
+export { applySafeAutoFixes, type ConfigBackup, type ConfigDoctorResult, type ConfigFinding, type ConfigFix, createConfigBackup, type FindingSeverity, getConfigPaths, runConfigDoctor, runConfigDoctorWithFixes, shouldRunOnStartup, writeBackupArtifact, writeDoctorArtifact, } from './config-doctor';
+export { type DiagnoseData, formatDiagnoseMarkdown, getDiagnoseData, type HealthCheck, handleDiagnoseCommand, } from './diagnose-service';
+export { type EvidenceEntryData, type EvidenceListData, formatEvidenceListMarkdown, formatTaskEvidenceMarkdown, getEvidenceListData, getTaskEvidenceData, getVerdictEmoji, handleEvidenceCommand, type TaskEvidenceData, } from './evidence-service';
+export { buildEvidenceSummary, EVIDENCE_SUMMARY_VERSION, type EvidenceSummaryArtifact, isAutoSummaryEnabled, type PhaseBlocker, type PhaseEvidenceSummary, REQUIRED_EVIDENCE_TYPES, type TaskEvidenceSummary, } from './evidence-summary-service';
+export { type ExportData, formatExportMarkdown, getExportData, handleExportCommand, } from './export-service';
+export { formatHistoryMarkdown, getHistoryData, type HistoryData, handleHistoryCommand, type PhaseHistoryData, } from './history-service';
+export { formatPlanMarkdown, getPlanData, handlePlanCommand, type PlanData, } from './plan-service';
+export { createPreflightIntegration, type PreflightIntegrationConfig, runManualPreflight, } from './preflight-integration';
+export { formatPreflightMarkdown, handlePreflightCommand, type PreflightCheckResult, type PreflightCheckType, type PreflightConfig, type PreflightReport, runPreflight, } from './preflight-service';
+export { formatStatusMarkdown, getStatusData, handleStatusCommand, type StatusData, } from './status-service';

package/dist/services/plan-service.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured plan data for a specific phase or full plan.
+ */
+export interface PlanData {
+    hasPlan: boolean;
+    fullMarkdown: string;
+    requestedPhase: number | null;
+    phaseMarkdown: string | null;
+    errorMessage: string | null;
+    isLegacy: boolean;
+}
+/**
+ * Get plan data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getPlanData(directory: string, phaseArg?: string | number): Promise<PlanData>;
+/**
+ * Format plan data as markdown for command output.
+ */
+export declare function formatPlanMarkdown(planData: PlanData): string;
+/**
+ * Handle plan command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handlePlanCommand(directory: string, args: string[]): Promise<string>;

package/dist/services/preflight-integration.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Preflight Background Integration
+ *
+ * Wires the preflight service to background automation:
+ * - Subscribes to preflight.requested events
+ * - Runs preflight checks
+ * - Updates status artifact with results
+ */
+import { PreflightTriggerManager } from '../background/trigger';
+import type { AutomationConfig } from '../config/schema';
+import { type PreflightConfig, type PreflightReport } from '../services/preflight-service';
+/** Integration configuration */
+export interface PreflightIntegrationConfig {
+    /** Automation configuration (required for capability gating) */
+    automationConfig: AutomationConfig;
+    /** Directory to run preflight in */
+    directory: string;
+    /** Swarm directory for status artifact */
+    swarmDir: string;
+    /** Preflight check configuration */
+    preflightConfig?: PreflightConfig;
+    /** Whether to update status artifact (default true) */
+    updateStatusArtifact?: boolean;
+}
+/**
+ * Create preflight integration
+ *
+ * Sets up the handler that will be called when preflight is requested.
+ * Returns the trigger manager and cleanup function.
+ */
+export declare function createPreflightIntegration(config: PreflightIntegrationConfig): {
+    manager: PreflightTriggerManager;
+    cleanup: () => void;
+};
+/**
+ * Run preflight manually (for testing or CLI)
+ */
+export declare function runManualPreflight(directory: string, phase: number, config?: PreflightConfig): Promise<PreflightReport>;

package/dist/services/preflight-service.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Preflight Automation Service
+ *
+ * Runs automated preflight checks for release readiness:
+ * - lint check
+ * - tests check (sane verification scope)
+ * - secrets check
+ * - evidence completeness check
+ * - version consistency check
+ *
+ * Returns deterministic structured result with per-check status + overall verdict.
+ * Callable by background flow (from preflight.requested events).
+ */
+/** Preflight check types */
+export type PreflightCheckType = 'lint' | 'tests' | 'secrets' | 'evidence' | 'version';
+/** Individual check status */
+export interface PreflightCheckResult {
+    type: PreflightCheckType;
+    status: 'pass' | 'fail' | 'skip' | 'error';
+    message: string;
+    details?: Record<string, unknown>;
+    durationMs?: number;
+}
+/** Preflight report structure */
+export interface PreflightReport {
+    id: string;
+    timestamp: number;
+    phase: number;
+    overall: 'pass' | 'fail' | 'skipped';
+    checks: PreflightCheckResult[];
+    totalDurationMs: number;
+    message: string;
+}
+/** Preflight configuration */
+export interface PreflightConfig {
+    /** Timeout per check in ms (default 60s, min 5s, max 300s) */
+    checkTimeoutMs?: number;
+    /** Skip tests check (default false) */
+    skipTests?: boolean;
+    /** Skip secrets check (default false) */
+    skipSecrets?: boolean;
+    /** Skip evidence check (default false) */
+    skipEvidence?: boolean;
+    /** Skip version check (default false) */
+    skipVersion?: boolean;
+    /** Test scope (default 'convention' for faster preflight) */
+    testScope?: 'all' | 'convention' | 'graph';
+    /** Linter to use (default 'biome') */
+    linter?: 'biome' | 'eslint';
+}
+/**
+ * Run all preflight checks
+ */
+export declare function runPreflight(dir: string, phase: number, config?: PreflightConfig): Promise<PreflightReport>;
+/**
+ * Format preflight report as markdown
+ */
+export declare function formatPreflightMarkdown(report: PreflightReport): string;
+/**
+ * Handle preflight command - thin adapter for CLI
+ */
+export declare function handlePreflightCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/status-service.d.ts

@@ -0,0 +1,28 @@
+import type { AgentDefinition } from '../agents';
+/**
+ * Structured status data returned by the status service.
+ * This can be used by GUI, background flows, or command adapters.
+ */
+export interface StatusData {
+    hasPlan: boolean;
+    currentPhase: string;
+    completedTasks: number;
+    totalTasks: number;
+    agentCount: number;
+    isLegacy: boolean;
+}
+/**
+ * Get status data from the swarm directory.
+ * Returns structured data that can be used by GUI, background flows, or commands.
+ */
+export declare function getStatusData(directory: string, agents: Record<string, AgentDefinition>): Promise<StatusData>;
+/**
+ * Format status data as markdown for command output.
+ * This is the thin adapter that delegates to the service.
+ */
+export declare function formatStatusMarkdown(status: StatusData): string;
+/**
+ * Handle status command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleStatusCommand(directory: string, agents: Record<string, AgentDefinition>): Promise<string>;

package/dist/tools/secretscan.d.ts

@@ -28,4 +28,8 @@ export interface SecretscanErrorResult {
     skipped_files: 0;
 }
 export declare const secretscan: ReturnType<typeof tool>;
+/**
+ * Run secretscan programmatically
+ */
+export declare function runSecretscan(directory: string): Promise<SecretscanResult | SecretscanErrorResult>;
 export {};