opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/tools/get-approved-plan.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Tool to retrieve the last critic-approved immutable plan snapshot.
+ *
+ * Wraps `loadLastApprovedPlan` from `src/plan/ledger.ts` as a tool callable
+ * by the critic `phase_drift_verifier` agent. Enables active baseline drift
+ * comparison: the drift verifier can compare the immutable approved snapshot
+ * against the current `plan.json` to detect silent plan mutations introduced
+ * after approval.
+ *
+ * The tool internally derives `plan_id` from the current plan for
+ * cross-identity safety — the caller does not need to know the format.
+ *
+ * Read-only: no file writes.
+ *
+ * @see https://github.com/zaxbysauce/opencode-swarm/issues/449
+ */
+import type { tool } from '@opencode-ai/plugin';
+interface GetApprovedPlanResult {
+    success: boolean;
+    reason?: string;
+    approved_plan?: ApprovedPlanPayload;
+    current_plan?: CurrentPlanPayload | null;
+    drift_detected?: boolean | 'unknown';
+    current_plan_error?: string;
+    /** SHA-256 hex digest over {plan_id, gates} of the current QA gate profile,
+     *  or null when no profile exists for this plan. Used by the critic to
+     *  detect silent gate mutations post-approval. */
+    qa_profile_hash?: string | null;
+}
+interface ApprovedPlanPayload {
+    plan: unknown;
+    approval_metadata: Record<string, unknown> | undefined;
+    snapshot_seq: number;
+    snapshot_timestamp: string;
+    payload_hash: string;
+    /** The execution_profile from the approved snapshot, if any. */
+    execution_profile?: {
+        parallelization_enabled: boolean;
+        max_concurrent_tasks: number;
+        council_parallel: boolean;
+        locked: boolean;
+    } | null;
+}
+interface CurrentPlanPayload {
+    plan: unknown;
+    current_hash: string;
+}
+/**
+ * Core execution logic — exported for direct testing.
+ */
+export declare function executeGetApprovedPlan(args: {
+    summary_only?: boolean;
+}, directory: string): Promise<GetApprovedPlanResult>;
+export declare const get_approved_plan: ReturnType<typeof tool>;
+export {};

package/dist/tools/get-qa-gate-profile.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool to retrieve the QA gate profile for the current plan.
+ *
+ * Read-only: derives plan_id from plan.json, then looks up the profile in the
+ * per-project DB. Returns the spec-level profile gates, lock state, and profile
+ * hash. Callers layering session overrides should combine with
+ * `getEffectiveGates` themselves — this tool intentionally returns the
+ * persisted/locked spec-level view.
+ */
+import type { tool } from '@opencode-ai/plugin';
+interface GetQaGateProfileResult {
+    success: boolean;
+    reason?: string;
+    plan_id?: string;
+    profile?: {
+        plan_id: string;
+        project_type: string | null;
+        gates: Record<string, boolean>;
+        locked_at: string | null;
+        locked_by_snapshot_seq: number | null;
+        created_at: string;
+        profile_hash: string;
+    };
+}
+export declare function executeGetQaGateProfile(_args: Record<string, unknown>, directory: string): Promise<GetQaGateProfileResult>;
+export declare const get_qa_gate_profile: ReturnType<typeof tool>;
+export {};

package/dist/tools/gitingest.d.ts

@@ -0,0 +1,18 @@
+import { createSwarmTool } from './create-tool';
+export interface GitingestArgs {
+    url: string;
+    maxFileSize?: number;
+    pattern?: string;
+    patternType?: 'include' | 'exclude';
+}
+export declare const GITINGEST_TIMEOUT_MS = 10000;
+export declare const GITINGEST_MAX_RESPONSE_BYTES = 5242880;
+export declare const GITINGEST_MAX_RETRIES = 2;
+/**
+ * Fetch repository content via gitingest.com API with timeout, size guard, and retry logic
+ */
+export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
+/**
+ * Gitingest tool for fetching GitHub repository contents
+ */
+export declare const gitingest: ReturnType<typeof createSwarmTool>;

package/dist/tools/imports.d.ts

@@ -0,0 +1,5 @@
+import { createSwarmTool } from './create-tool';
+/**
+ * Main imports tool implementation
+ */
+export declare const imports: ReturnType<typeof createSwarmTool>;

package/dist/tools/index.d.ts

@@ -0,0 +1,66 @@
+export { batch_symbols } from './batch-symbols';
+export { build_check } from './build-check';
+export { check_gate_status } from './check-gate-status';
+export { checkpoint } from './checkpoint';
+export { co_change_analyzer } from './co-change-analyzer';
+export { completion_verify } from './completion-verify';
+export { complexity_hotspots } from './complexity-hotspots';
+export { submit_council_verdicts } from './convene-council';
+export { convene_general_council } from './convene-general-council';
+export { curator_analyze } from './curator-analyze';
+export { declare_council_criteria } from './declare-council-criteria';
+export { declare_scope } from './declare-scope';
+export { type DiffErrorResult, type DiffResult, diff } from './diff';
+export { diff_summary } from './diff-summary';
+export { doc_extract, doc_scan } from './doc-scan';
+export { detect_domains } from './domain-detector';
+export { evidence_check } from './evidence-check';
+export { extract_code_blocks } from './file-extractor';
+export { get_approved_plan } from './get-approved-plan';
+export { get_qa_gate_profile } from './get-qa-gate-profile';
+export { fetchGitingest, type GitingestArgs, gitingest } from './gitingest';
+export { imports } from './imports';
+export { knowledge_add } from './knowledge-add';
+export { knowledge_query } from './knowledge-query';
+export { knowledge_recall } from './knowledge-recall';
+export { knowledge_remove } from './knowledge-remove';
+export { lint } from './lint';
+export { phase_complete } from './phase-complete';
+export { pkg_audit } from './pkg-audit';
+export { type PlaceholderFinding, type PlaceholderScanInput, type PlaceholderScanResult, placeholder_scan, placeholderScan, } from './placeholder-scan';
+export { type PreCheckBatchInput, type PreCheckBatchResult, pre_check_batch, runPreCheckBatch, type ToolResult, } from './pre-check-batch';
+export { type QualityBudgetInput, type QualityBudgetResult, quality_budget, qualityBudget, } from './quality-budget';
+export { buildWorkspaceGraph, type GraphEdge, type GraphNode, loadGraph, loadOrCreateGraph, type RepoGraph, resolveModuleSpecifier, saveGraph, updateGraphForFiles, } from './repo-graph';
+export { repo_map } from './repo-map';
+export { req_coverage } from './req-coverage';
+export { retrieve_summary } from './retrieve-summary';
+export { type SastScanFinding, type SastScanInput, type SastScanResult, sast_scan, sastScan, } from './sast-scan';
+export type { SavePlanArgs, SavePlanResult } from './save-plan';
+export { save_plan } from './save-plan';
+export { type SbomGenerateInput, type SbomGenerateResult, sbom_generate, } from './sbom-generate';
+export { schema_drift } from './schema-drift';
+export { search } from './search';
+export { type SecretFinding, type SecretscanResult, secretscan, } from './secretscan';
+export { set_qa_gates } from './set-qa-gates';
+import { suggestPatch } from './suggest-patch';
+export { suggestPatch };
+export type { SuggestPatchArgs } from './suggest-patch';
+export declare const suggest_patch: typeof suggestPatch;
+export type { ClassifiedFailure, FailureClassification, FailureCluster, } from '../test-impact/failure-classifier.js';
+export { classifyAndCluster, classifyFailure, clusterFailures, } from '../test-impact/failure-classifier.js';
+export type { FlakyTestEntry } from '../test-impact/flaky-detector.js';
+export { computeFlakyScore, detectFlakyTests, isTestQuarantined, } from '../test-impact/flaky-detector.js';
+export { generate_mutants } from './generate-mutants';
+export { lint_spec } from './lint-spec';
+export { mutation_test } from './mutation-test';
+export { symbols } from './symbols';
+export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntax_check, syntaxCheck, } from './syntax-check';
+export { test_impact } from './test-impact';
+export { test_runner } from './test-runner';
+export { todo_extract } from './todo-extract';
+export { executeUpdateTaskStatus, type UpdateTaskStatusArgs, type UpdateTaskStatusResult, update_task_status, } from './update-task-status';
+export { web_search } from './web-search';
+export { write_drift_evidence } from './write-drift-evidence';
+export { write_hallucination_evidence } from './write-hallucination-evidence';
+export { write_mutation_evidence } from './write-mutation-evidence';
+export { executeWriteRetro, write_retro } from './write-retro';

package/dist/tools/knowledge-add.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool.js';
+export declare const knowledge_add: ReturnType<typeof createSwarmTool>;

package/dist/tools/knowledge-query.d.ts

@@ -0,0 +1,5 @@
+/** Knowledge query tool for architect-level access to swarm and hive knowledge.
+ * Provides filtered, formatted text output for knowledge retrieval.
+ */
+import type { tool } from '@opencode-ai/plugin';
+export declare const knowledge_query: ReturnType<typeof tool>;

package/dist/tools/knowledge-recall.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool.js';
+export declare const knowledge_recall: ReturnType<typeof createSwarmTool>;

package/dist/tools/knowledge-remove.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool.js';
+export declare const knowledge_remove: ReturnType<typeof createSwarmTool>;

package/dist/tools/knowledge-tools.integration.test.d.ts

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

package/dist/tools/lint-spec.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool';
+export declare const lint_spec: ReturnType<typeof createSwarmTool>;

package/dist/tools/lint.d.ts

@@ -0,0 +1,63 @@
+import type { tool } from '@opencode-ai/plugin';
+export declare const MAX_OUTPUT_BYTES = 512000;
+export declare const MAX_COMMAND_LENGTH = 500;
+export declare const SUPPORTED_LINTERS: readonly ["biome", "eslint"];
+export type SupportedLinter = (typeof SUPPORTED_LINTERS)[number];
+export type AdditionalLinter = 'ruff' | 'clippy' | 'golangci-lint' | 'checkstyle' | 'ktlint' | 'dotnet-format' | 'cppcheck' | 'swiftlint' | 'dart-analyze' | 'rubocop';
+export interface LintSuccessResult {
+    success: true;
+    mode: 'fix' | 'check';
+    linter: SupportedLinter | AdditionalLinter;
+    command: string[];
+    exitCode: number;
+    output: string;
+    message?: string;
+}
+export interface LintErrorResult {
+    success: false;
+    mode: 'fix' | 'check';
+    linter?: SupportedLinter | AdditionalLinter;
+    command?: string[];
+    exitCode?: number;
+    output?: string;
+    error: string;
+    message?: string;
+}
+export type LintResult = LintSuccessResult | LintErrorResult;
+export { containsControlChars, containsPathTraversal, } from '../utils/path-security';
+export declare function validateArgs(args: unknown): args is {
+    mode: 'fix' | 'check';
+};
+export declare function getLinterCommand(linter: SupportedLinter, mode: 'fix' | 'check', projectDir: string): string[];
+/**
+ * Build the shell command for an additional (non-JS/TS) linter.
+ * cppcheck has no --fix mode; csharp and some others behave differently.
+ */
+export declare function getAdditionalLinterCommand(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): string[];
+/**
+ * Detect the first available additional (non-JS/TS) linter for the current project.
+ * Returns null when no additional linter is detected or its binary is unavailable.
+ */
+export declare function detectAdditionalLinter(cwd: string): 'ruff' | 'clippy' | 'golangci-lint' | 'checkstyle' | 'ktlint' | 'dotnet-format' | 'cppcheck' | 'swiftlint' | 'dart-analyze' | 'rubocop' | null;
+/** Compute the local biome binary path for a given project directory. */
+export declare function getBiomeBinPath(directory: string): string;
+/**
+ * Resolve the binary path for a linter, using the same hierarchy as detectAvailableLinter:
+ * 1. Local node_modules/.bin
+ * 2. Ancestor node_modules/.bin (monorepo)
+ * 3. process.env.PATH scan
+ * 4. Local path as fallback (may not exist)
+ */
+export declare function resolveLinterBinPath(linter: SupportedLinter, projectDir: string): string;
+/** Compute the local eslint binary path for a given project directory. */
+export declare function getEslintBinPath(directory: string): string;
+export declare function detectAvailableLinter(directory?: string): Promise<SupportedLinter | null>;
+/** Internal implementation — accepts pre-computed binary paths for testability. */
+export declare function _detectAvailableLinter(_projectDir: string, biomeBin: string, eslintBin: string): Promise<SupportedLinter | null>;
+export declare function runLint(linter: SupportedLinter, mode: 'fix' | 'check', directory: string): Promise<LintResult>;
+/**
+ * Run an additional (non-JS/TS) linter.
+ * Follows the same structure as runLint() but uses getAdditionalLinterCommand().
+ */
+export declare function runAdditionalLint(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): Promise<LintResult>;
+export declare const lint: ReturnType<typeof tool>;

package/dist/tools/mutation-test.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool';
+export declare const mutation_test: ReturnType<typeof createSwarmTool>;

package/dist/tools/mutation-test.security.test.d.ts

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

package/dist/tools/phase-complete.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Phase completion tool for tracking and validating phase completion.
+ * Core implementation - gathers data, enforces policy, writes event, resets state.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the phase_complete tool
+ */
+export interface PhaseCompleteArgs {
+    /** The phase number being completed */
+    phase: number;
+    /** Optional summary of the phase */
+    summary?: string;
+    /** Session ID to track state (optional, defaults to current session context) */
+    sessionID?: string;
+}
+/**
+ * Execute the phase_complete tool
+ * Gathers data, enforces policy, writes event, resets state
+ */
+export declare function executePhaseComplete(args: PhaseCompleteArgs, workingDirectory?: string, directory?: string): Promise<string>;
+/**
+ * Tool definition for phase_complete
+ */
+export declare const phase_complete: ToolDefinition;

package/dist/tools/pkg-audit.d.ts

@@ -0,0 +1,2 @@
+import type { tool } from '@opencode-ai/plugin';
+export declare const pkg_audit: ReturnType<typeof tool>;

package/dist/tools/placeholder-scan.d.ts

@@ -0,0 +1,28 @@
+import type { tool } from '@opencode-ai/plugin';
+import type { EvidenceVerdict } from '../config/evidence-schema';
+export interface PlaceholderScanInput {
+    changed_files: string[];
+    allow_globs?: string[];
+    deny_patterns?: string[];
+}
+export interface PlaceholderFinding {
+    path: string;
+    line: number;
+    kind: 'comment' | 'string' | 'function_body' | 'other';
+    excerpt: string;
+    rule_id: string;
+}
+export interface PlaceholderScanResult {
+    verdict: EvidenceVerdict;
+    findings: PlaceholderFinding[];
+    summary: {
+        files_scanned: number;
+        findings_count: number;
+        files_with_findings: number;
+    };
+}
+/**
+ * Scan files for placeholder content (TODO/FIXME comments, stub implementations, etc.)
+ */
+export declare function placeholderScan(input: PlaceholderScanInput, directory: string): Promise<PlaceholderScanResult>;
+export declare const placeholder_scan: ReturnType<typeof tool>;

package/dist/tools/plugin-registration-adversarial.test.d.ts

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

package/dist/tools/pre-check-batch.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Pre-Check Batch Tool
+ * Runs 4 verification tools in parallel: lint, secretscan, sast-scan, quality-budget
+ * Returns unified result with gates_passed status
+ */
+import type { tool } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+import type { LintResult } from './lint';
+import type { QualityBudgetResult } from './quality-budget';
+import type { SastScanFinding, SastScanResult } from './sast-scan';
+import type { SecretscanErrorResult, SecretscanResult } from './secretscan';
+export interface PreCheckBatchInput {
+    /** List of specific files to check (optional) */
+    files?: string[];
+    /** Directory to scan */
+    directory: string;
+    /** SAST severity threshold (default: medium) */
+    sast_threshold?: 'low' | 'medium' | 'high' | 'critical';
+    /** Optional plugin config */
+    config?: PluginConfig;
+    /**
+     * Current phase number (positive integer >= 1).
+     * When provided, enables SAST baseline diffing: only findings absent from the
+     * phase-scoped baseline (.swarm/evidence/{phase}/sast-baseline.json) drive the
+     * fail verdict. Capture the baseline before first coder delegation via sast_scan
+     * with capture_baseline:true.
+     */
+    phase?: number;
+}
+export interface ToolResult<T> {
+    /** Whether the tool was executed */
+    ran: boolean;
+    /** Tool result if successful */
+    result?: T;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    duration_ms: number;
+}
+export interface PreCheckBatchResult {
+    /** Overall gate status: true if all security gates pass */
+    gates_passed: boolean;
+    /** Lint tool result */
+    lint: ToolResult<LintResult>;
+    /** Secretscan tool result */
+    secretscan: ToolResult<SecretscanResult | SecretscanErrorResult>;
+    /** SAST scan tool result */
+    sast_scan: ToolResult<SastScanResult>;
+    /** Quality budget tool result */
+    quality_budget: ToolResult<QualityBudgetResult>;
+    /** Total duration in milliseconds */
+    total_duration_ms: number;
+    /** Pre-existing SAST findings on unchanged lines, requiring reviewer triage */
+    sast_preexisting_findings?: SastScanFinding[];
+}
+/**
+ * Parse unified diff output (with -U0) to extract added/modified line numbers per file.
+ * Returns a Map from normalised file path → Set of changed line numbers.
+ */
+export declare function parseDiffLineRanges(diffOutput: string): Map<string, Set<number>>;
+/**
+ * Get changed line ranges for the current branch vs its base.
+ * Tries three strategies in order:
+ * 1. merge-base diff against main/master (captures all branch changes, works after commit)
+ * 2. HEAD~1 (single-commit diff, works after commit)
+ * 3. HEAD (unstaged/staged changes, works before commit)
+ * Returns null if git is unavailable or no changes found.
+ */
+export declare function getChangedLineRanges(directory: string): Promise<Map<string, Set<number>> | null>;
+/**
+ * Classify SAST findings as "new" (on changed lines) or "pre-existing" (unchanged lines).
+ * A finding is "new" if its file+line intersects the changed line ranges from git diff.
+ * If line ranges cannot be determined (git unavailable), all findings are treated as new (fail-closed).
+ */
+export declare function classifySastFindings(findings: SastScanFinding[], changedLineRanges: Map<string, Set<number>> | null, directory: string): {
+    newFindings: SastScanFinding[];
+    preexistingFindings: SastScanFinding[];
+};
+/**
+ * Run all 4 pre-check tools in parallel with concurrency limit
+ * @param input - The pre-check batch input
+ * @param workspaceDir - Optional workspace directory for traversal validation (defaults to directory param or process.cwd())
+ */
+export declare function runPreCheckBatch(input: PreCheckBatchInput, workspaceDir?: string, contextDir?: string): Promise<PreCheckBatchResult>;
+/**
+ * Pre-check batch tool - runs 4 verification tools in parallel
+ * Returns unified result with gates_passed status
+ */
+export declare const pre_check_batch: ReturnType<typeof tool>;

package/dist/tools/quality-budget.d.ts

@@ -0,0 +1,26 @@
+import type { tool } from '@opencode-ai/plugin';
+import type { QualityBudgetConfig } from '../config/schema';
+import { type QualityMetrics, type QualityViolation } from '../quality/metrics';
+export interface QualityBudgetInput {
+    changed_files: string[];
+    config?: Partial<QualityBudgetConfig>;
+}
+export interface QualityBudgetResult {
+    verdict: 'pass' | 'fail';
+    metrics: QualityMetrics;
+    violations: QualityViolation[];
+    summary: {
+        files_analyzed: number;
+        violations_count: number;
+        errors_count: number;
+        warnings_count: number;
+    };
+}
+/**
+ * Quality budget tool - enforces maintainability budgets for changed files
+ *
+ * Computes quality metrics (complexity, API, duplication, test ratio)
+ * and compares against configured thresholds to ensure code quality.
+ */
+export declare function qualityBudget(input: QualityBudgetInput, directory: string): Promise<QualityBudgetResult>;
+export declare const quality_budget: ReturnType<typeof tool>;