scip-query 0.24.0 → 0.26.0

package/dist/queries/review.d.ts

@@ -0,0 +1,188 @@
+import { ArchitectureReport, ArchitectureBoundarySummary, ArchitectureCoverage, ArchitecturePolicyCoverage } from './architecture.js';
+import { G as ArchitectureConfig } from '../config-types-B9B60MiR.js';
+import '../db-BwIVAYNB.js';
+import 'better-sqlite3';
+
+interface ComplexityContribution {
+    line: number;
+    column: number;
+    kind: string;
+    cyclomatic: number;
+    cognitive: number;
+}
+interface SourceFunction {
+    name: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    startOffset: number;
+    endOffset: number;
+    sourceHash: string;
+    bodyHash: string;
+    renamedBodyHash: string;
+    tokenCount: number;
+    cyclomatic: number;
+    cognitive: number;
+    contributions: ComplexityContribution[];
+}
+
+type ImportResolution = 'internal' | 'external' | 'builtin' | 'excluded' | 'missing' | 'ambiguous' | 'dynamic';
+interface SourceImport {
+    file: string;
+    line: number;
+    specifier: string;
+    target?: string;
+    kind: 'value' | 'type';
+    role: 'production' | 'test';
+    syntax: 'import' | 'reexport' | 'require' | 'dynamic-import' | 'type-import';
+    resolution: ImportResolution;
+    configs: string[];
+    alternatives?: string[];
+    excludedReason?: string;
+}
+
+type FunctionCoverage = {
+    status: 'unavailable';
+    reason: string;
+} | {
+    status: 'available';
+    basis: 'istanbul-statement-start-lines';
+    coveredLines: number;
+    measuredLines: number;
+    fraction: number;
+    crap: number;
+};
+
+interface FindingSite {
+    file: string;
+    line: number;
+    name?: string;
+}
+interface SourceFinding {
+    id: string;
+    rule: 'complexity' | 'duplication' | 'dependency-cycle' | 'architecture' | 'crap' | 'broken-dependency' | 'responsibility';
+    evidence: 'derived' | 'candidate';
+    summary: string;
+    sites: FindingSite[];
+    score: number;
+    details: string[];
+    status?: 'introduced' | 'worsened' | 'existing' | 'resolved' | 'uncomparable';
+}
+interface MeasuredFunction extends SourceFunction {
+    coverage: FunctionCoverage;
+}
+
+interface SourceModuleSubject {
+    id: string;
+    basis: 'declared-boundary' | 'directory';
+    files: string[];
+    consumers: string[];
+    dependencies: string[];
+    findingIds: string[];
+    primaryFindingIds: string[];
+    highestPriority: SourceFinding['rule'];
+    interpretation: string;
+}
+
+type SuppressionAdjudicationResult = {
+    kind: 'accepted';
+} | {
+    kind: 'expired' | 'invalidated' | 'escalated';
+    reasons: string[];
+};
+
+interface SourceScanOptions {
+    includeTests?: boolean;
+    includeReferences?: boolean;
+    includeGenerated?: boolean;
+    maxFiles?: number;
+    maxFileBytes?: number;
+}
+
+interface SourceSuppressionDecision {
+    id?: string;
+    check?: string;
+    file?: string;
+    outcome: SuppressionAdjudicationResult['kind'] | 'unmatched';
+    reasons: string[];
+}
+
+/** Keep the source report's policy context compact; full indexed graph evidence has its own command. */
+declare function sourceArchitectureContext(rules: ArchitectureReport): {
+    configured: boolean;
+    boundaries: ArchitectureBoundarySummary[];
+    coverage: ArchitectureCoverage;
+    policyCoverage: ArchitecturePolicyCoverage;
+    dependencyRoles: {
+        excludedTestEdges: number;
+        basis: "production-imports-including-types";
+        cycleMeaning: string;
+    } | undefined;
+    cycles: {
+        boundaries: string[];
+        origin: "contains-file-cycle" | "grouping-only" | undefined;
+        fileCycleMembers: string[] | undefined;
+        violatesPolicy: boolean;
+    }[];
+};
+declare function dependencyCoverage(imports: readonly SourceImport[]): {
+    resolutions: Record<ImportResolution, number>;
+    typeOnly: number;
+    test: number;
+    deferredOrCommonJs: number;
+    unresolved: SourceImport[];
+    excluded: SourceImport[];
+};
+
+interface SourceReviewOptions extends SourceScanOptions {
+    base?: string;
+    coverage?: string;
+    scope?: string;
+    architecture?: ArchitectureConfig;
+}
+interface FunctionChange {
+    status: 'added' | 'modified' | 'removed' | 'uncomparable';
+    before?: MeasuredFunction;
+    after?: MeasuredFunction;
+    delta?: {
+        cyclomatic: number;
+        cognitive: number;
+    };
+}
+interface SourceMaintenanceReport {
+    mode: 'health' | 'review';
+    base?: string;
+    current: string;
+    metricRules: string;
+    changedFiles: string[];
+    configurationChanges: string[];
+    relationshipChangedFiles: string[];
+    architecture: ReturnType<typeof sourceArchitectureContext>;
+    functions: FunctionChange[];
+    findings: SourceFinding[];
+    suppressionDecisions: SourceSuppressionDecision[];
+    blockingFindingIds: string[];
+    modules: SourceModuleSubject[];
+    affectedFiles: string[];
+    coverage: {
+        status: 'accounted' | 'incomplete';
+        analyzedFiles: number;
+        eligibleFiles: number;
+        excludedFiles: number;
+        exclusions: Record<string, number>;
+        dependencies: ReturnType<typeof dependencyCoverage>;
+        analyzedFunctions: number;
+        unresolvedImports: number;
+        testCoverage: {
+            requested: boolean;
+            available: number;
+            unavailable: number;
+            reasons: string[];
+        };
+        problems: string[];
+        limits: string[];
+    };
+}
+declare function sourceMaintenanceReport(projectRoot: string, opts?: SourceReviewOptions): SourceMaintenanceReport;
+
+export { type FunctionChange, type SourceMaintenanceReport, type SourceReviewOptions, sourceMaintenanceReport };

package/dist/queries/review.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-INLMWEUU.js";import"../chunk-YRT2WLYY.js";import"../chunk-FC2EVQRM.js";import"../chunk-ETOIKRHO.js";import"../chunk-SV2LEFVM.js";import"../chunk-HXENDJC6.js";import"../chunk-2IWUT6CJ.js";import"../chunk-4WCUBZU3.js";import"../chunk-E3FDPXZK.js";import"../chunk-DHEQMPLW.js";import"../chunk-KHWRRPV4.js";import"../chunk-72AD6ZRR.js";import"../chunk-YUKYB54I.js";import"../chunk-GCKCF5FL.js";import"../chunk-5D2LVK7O.js";import"../chunk-7WTPQ4NX.js";import"../chunk-FVULPZDF.js";import"../chunk-D3FDISIC.js";import"../chunk-A2IIGFMJ.js";import"../chunk-PH52RA7D.js";import"../chunk-GVWX5T43.js";import"../chunk-T6DK3ZP7.js";import"../chunk-5TNQJUR2.js";export{a as sourceMaintenanceReport};
+//# sourceMappingURL=review.js.map

package/dist/queries/similar-files.d.ts

@@ -5,8 +5,10 @@ import '../config-types-B9B60MiR.js';
 interface SimilarFileResult {
     fileA: string;
     fileB: string;
-    /** Jaccard similarity of dependency sets (0-1) */
+    /** Jaccard similarity after excluding dependencies imported by >=5 files and >30% of the repository. */
     similarity: number;
+    /** Candidate relationship based on filtered dependency sets, not behavioral equivalence. */
+    evidenceBasis: 'filtered-dependency-overlap';
     sharedDeps: string[];
     uniqueToA: string[];
     uniqueToB: string[];
@@ -14,15 +16,10 @@ interface SimilarFileResult {
 /**
  * Find files with similar dependency profiles.
  *
- * Two files that depend on (import from) the same set of other files
- * are structurally doing similar work. High Jaccard similarity between
- * their dependency sets = likely copy-paste variants or consolidation candidates.
- *
- * Evidence policy: a pair must share at least two *distinctive* deps —
- * deps with low global fan-in. Files that overlap only on family
- * infrastructure (the modules everyone in their directory imports) are
- * not copy-paste variants; adapter families sharing an SDK scored 100%
- * before this gate while differing in everything that matters.
+ * Compares observed dependency sets after removing globally common dependencies.
+ * A result identifies shared structural dependencies; it does not establish
+ * duplicated behavior, a common conceptual owner, or safe consolidation.
+ * At least two low-popularity dependencies must be shared (one when minDeps=1).
  */
 declare function similarFiles(db: ScipDatabase, opts?: {
     minSimilarity?: number;

package/dist/queries/similar-files.js

@@ -1,2 +1,2 @@
-import{a}from"../chunk-7DUI77BN.js";import"../chunk-V2RBODHL.js";import"../chunk-KMVGRIO2.js";import"../chunk-BOW7SSQH.js";import"../chunk-RBAD4GJ2.js";import"../chunk-ZLMXIQLC.js";import"../chunk-ETC674NS.js";import"../chunk-KNLQGXVH.js";import"../chunk-JZ2A7LDM.js";export{a as similarFiles};
+import{a}from"../chunk-BMKOQJRI.js";import"../chunk-5PLMJC7Q.js";import"../chunk-NOLZOVCU.js";import"../chunk-GCKCF5FL.js";import"../chunk-7WTPQ4NX.js";import"../chunk-FVULPZDF.js";import"../chunk-D3FDISIC.js";import"../chunk-A2IIGFMJ.js";import"../chunk-PH52RA7D.js";import"../chunk-GVWX5T43.js";import"../chunk-T6DK3ZP7.js";import"../chunk-5TNQJUR2.js";export{a as similarFiles};
 //# sourceMappingURL=similar-files.js.map

package/dist/queries/similar-signatures.js

@@ -1,2 +1,2 @@
-import{a}from"../chunk-NKMKZP6A.js";import"../chunk-OIOC5EHF.js";import"../chunk-FJF6VO2P.js";import"../chunk-XKXTR6ZI.js";import"../chunk-BOJ5SVE2.js";import"../chunk-BGBBVSH4.js";import"../chunk-YSYPDRD5.js";import"../chunk-P5XHIJHI.js";import"../chunk-J6GLBBRK.js";import"../chunk-KK7GPALL.js";import"../chunk-QBQE7ZJ5.js";import"../chunk-NJQISBL4.js";import"../chunk-FLMTCX5R.js";import"../chunk-YUKYB54I.js";import"../chunk-DHEQMPLW.js";import"../chunk-BOW7SSQH.js";import"../chunk-MTDBHTSF.js";import"../chunk-C7C6AKAT.js";import"../chunk-RBAD4GJ2.js";import"../chunk-ZLMXIQLC.js";import"../chunk-ETC674NS.js";import"../chunk-KNLQGXVH.js";import"../chunk-JZ2A7LDM.js";export{a as similarSignatures};
+import{a}from"../chunk-EOV7RTRZ.js";import"../chunk-D254DNNQ.js";import"../chunk-4BP3UBDG.js";import"../chunk-KDDIE2DP.js";import"../chunk-BOJ5SVE2.js";import"../chunk-BGBBVSH4.js";import"../chunk-AGWFSTXC.js";import"../chunk-P5XHIJHI.js";import"../chunk-73AAKPUC.js";import"../chunk-KZBJWZJB.js";import"../chunk-KK7GPALL.js";import"../chunk-YNQCGEQE.js";import"../chunk-DA7RPPDF.js";import"../chunk-4WCUBZU3.js";import"../chunk-E3FDPXZK.js";import"../chunk-DHEQMPLW.js";import"../chunk-72AD6ZRR.js";import"../chunk-YUKYB54I.js";import"../chunk-GCKCF5FL.js";import"../chunk-DVFP6PZI.js";import"../chunk-5D2LVK7O.js";import"../chunk-7WTPQ4NX.js";import"../chunk-FVULPZDF.js";import"../chunk-D3FDISIC.js";import"../chunk-A2IIGFMJ.js";import"../chunk-PH52RA7D.js";import"../chunk-GVWX5T43.js";import"../chunk-T6DK3ZP7.js";import"../chunk-5TNQJUR2.js";export{a as similarSignatures};
 //# sourceMappingURL=similar-signatures.js.map

package/dist/queries/similar.d.ts

@@ -183,5 +183,23 @@ declare const SAME_FILE_SIBLING_SATURATION_THRESHOLD = 5;
 declare function trimSameFileSiblingSaturatedCallees(fingerprints: readonly SymbolFingerprint[]): SymbolFingerprint[];
 declare function meaningfulCallees(callees: Iterable<string>): Set<string>;
 declare function classifySimilarityEvidence(sharedEvidence: readonly string[], basis: NonNullable<SimilarSymbolResult['similarityBasis']>): SimilarEvidenceClassification;
+/** Same-file siblings share at least this much of their callee vocabulary before scaffolding vocabulary stops mattering. */
+declare const SIBLING_SIMILARITY_DIRECT_THRESHOLD = 0.5;
+/** Cross-file pairs whose shared callees mix domain behavior with scaffolding are direct from this similarity. */
+declare const MIXED_SIMILARITY_DIRECT_THRESHOLD = 0.6;
+/**
+ * Scaffolding vocabulary explains why two functions in different files look
+ * alike; it cannot explain two functions in one file that share half their
+ * callees, because the file's own imports are that vocabulary. Those siblings
+ * (create/update/delete workflows, archive/restore pairs) are the classic
+ * shared-step extraction and are reported as direct. A cross-file pair whose
+ * shared evidence already carries domain behavior next to the scaffolding is
+ * direct once the overlap is large.
+ */
+declare function promoteSiblingSimilarity(classification: SimilarEvidenceClassification, pair: {
+    similarity: number;
+    sharedCount: number;
+    sameFile: boolean;
+}): SimilarEvidenceClassification;
 
-export { type CalleeFingerprintCorpusOptions, type CalleeFingerprintIndex, type CalleeFingerprintIndexOptions, type RankedSimilarResult, SAME_FILE_SIBLING_SATURATION_THRESHOLD, type SimilarActionTier, type SimilarConsolidationPlan, type SimilarEvidenceClass, type SimilarEvidenceClassification, type SimilarSymbolResult, type SimilarityFingerprintProduct, type SourceCandidateMode, type SourceFingerprint, type SourceFingerprintCandidateOptions, type SourceFingerprintIndex, type SourceFingerprintOptions, type SymbolFingerprint, buildCalleeFingerprintIndex, candidateFingerprintsForTarget, classifySimilarityEvidence, comparePair, getAllCalleeFingerprints, getCalleeFingerprintIndex, insertTopSimilarResult, meaningfulCallees, similar, similarAll, similarAllCount, similarConsolidationPlan, similarityFingerprintProduct, targetSpecificIdfWeights, trimSameFileSiblingSaturatedCallees };
+export { type CalleeFingerprintCorpusOptions, type CalleeFingerprintIndex, type CalleeFingerprintIndexOptions, MIXED_SIMILARITY_DIRECT_THRESHOLD, type RankedSimilarResult, SAME_FILE_SIBLING_SATURATION_THRESHOLD, SIBLING_SIMILARITY_DIRECT_THRESHOLD, type SimilarActionTier, type SimilarConsolidationPlan, type SimilarEvidenceClass, type SimilarEvidenceClassification, type SimilarSymbolResult, type SimilarityFingerprintProduct, type SourceCandidateMode, type SourceFingerprint, type SourceFingerprintCandidateOptions, type SourceFingerprintIndex, type SourceFingerprintOptions, type SymbolFingerprint, buildCalleeFingerprintIndex, candidateFingerprintsForTarget, classifySimilarityEvidence, comparePair, getAllCalleeFingerprints, getCalleeFingerprintIndex, insertTopSimilarResult, meaningfulCallees, promoteSiblingSimilarity, similar, similarAll, similarAllCount, similarConsolidationPlan, similarityFingerprintProduct, targetSpecificIdfWeights, trimSameFileSiblingSaturatedCallees };

package/dist/queries/similar.js

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p}from"../chunk-ZFVPWH62.js";import"../chunk-KMVGRIO2.js";import"../chunk-BOJ5SVE2.js";import"../chunk-2BMSSRBH.js";import"../chunk-BGBBVSH4.js";import"../chunk-BJWFVAA5.js";import"../chunk-YSYPDRD5.js";import"../chunk-P5XHIJHI.js";import"../chunk-U3SXIMII.js";import"../chunk-J6GLBBRK.js";import"../chunk-SKKXTABJ.js";import"../chunk-KK7GPALL.js";import"../chunk-F5GSBHC6.js";import"../chunk-QBQE7ZJ5.js";import"../chunk-NJQISBL4.js";import"../chunk-FLMTCX5R.js";import"../chunk-YUKYB54I.js";import"../chunk-DHEQMPLW.js";import"../chunk-BOW7SSQH.js";import"../chunk-MTDBHTSF.js";import"../chunk-C7C6AKAT.js";import"../chunk-RBAD4GJ2.js";import"../chunk-ZLMXIQLC.js";import"../chunk-ETC674NS.js";import"../chunk-KNLQGXVH.js";import"../chunk-JZ2A7LDM.js";export{m as SAME_FILE_SIBLING_SATURATION_THRESHOLD,k as buildCalleeFingerprintIndex,l as candidateFingerprintsForTarget,p as classifySimilarityEvidence,d as comparePair,h as getAllCalleeFingerprints,i as getCalleeFingerprintIndex,g as insertTopSimilarResult,o as meaningfulCallees,a as similar,e as similarAll,f as similarAllCount,b as similarConsolidationPlan,j as similarityFingerprintProduct,c as targetSpecificIdfWeights,n as trimSameFileSiblingSaturatedCallees};
+import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s}from"../chunk-UXYXF7GV.js";import"../chunk-NOLZOVCU.js";import"../chunk-D254DNNQ.js";import"../chunk-4BP3UBDG.js";import"../chunk-KDDIE2DP.js";import"../chunk-BOJ5SVE2.js";import"../chunk-6LSEIIF7.js";import"../chunk-BGBBVSH4.js";import"../chunk-36SGVCGX.js";import"../chunk-AGWFSTXC.js";import"../chunk-P5XHIJHI.js";import"../chunk-73AAKPUC.js";import"../chunk-KZBJWZJB.js";import"../chunk-4WTUBQ36.js";import"../chunk-NZAXKGRL.js";import"../chunk-KK7GPALL.js";import"../chunk-YNQCGEQE.js";import"../chunk-FMRN2TRL.js";import"../chunk-DA7RPPDF.js";import"../chunk-4WCUBZU3.js";import"../chunk-E3FDPXZK.js";import"../chunk-DHEQMPLW.js";import"../chunk-KHWRRPV4.js";import"../chunk-72AD6ZRR.js";import"../chunk-YUKYB54I.js";import"../chunk-GCKCF5FL.js";import"../chunk-DVFP6PZI.js";import"../chunk-5D2LVK7O.js";import"../chunk-7WTPQ4NX.js";import"../chunk-FVULPZDF.js";import"../chunk-D3FDISIC.js";import"../chunk-A2IIGFMJ.js";import"../chunk-PH52RA7D.js";import"../chunk-GVWX5T43.js";import"../chunk-T6DK3ZP7.js";import"../chunk-5TNQJUR2.js";export{r as MIXED_SIMILARITY_DIRECT_THRESHOLD,m as SAME_FILE_SIBLING_SATURATION_THRESHOLD,q as SIBLING_SIMILARITY_DIRECT_THRESHOLD,k as buildCalleeFingerprintIndex,l as candidateFingerprintsForTarget,p as classifySimilarityEvidence,d as comparePair,h as getAllCalleeFingerprints,i as getCalleeFingerprintIndex,g as insertTopSimilarResult,o as meaningfulCallees,s as promoteSiblingSimilarity,a as similar,e as similarAll,f as similarAllCount,b as similarConsolidationPlan,j as similarityFingerprintProduct,c as targetSpecificIdfWeights,n as trimSameFileSiblingSaturatedCallees};
 //# sourceMappingURL=similar.js.map

package/dist/queries/slice-cohesion.d.ts

@@ -0,0 +1,205 @@
+import * as TypeScript from 'typescript';
+import { I as IndexedDefinition } from '../symbol-types-BIQwfoAx.js';
+import { S as ScipDatabase } from '../db-BwIVAYNB.js';
+import 'better-sqlite3';
+import '../config-types-B9B60MiR.js';
+
+interface CandidatePipelineCounters {
+    pipeline: string | undefined;
+    loadedCandidates: number;
+    filteredCandidates: number;
+    scannedCandidates: number;
+    evaluatedCandidates: number;
+    matchedResults: number;
+    emittedResults: number;
+    scanLimitApplied: boolean;
+    resultLimitApplied: boolean;
+}
+interface CandidateScanProgress {
+    evaluated: number;
+    scanned: number;
+    matched: number;
+}
+
+/** What a function hands to the outside world: a value, a field of a returned object, an effect, a write, or an exit. */
+type SliceCohesionOutputKind = 'return' | 'return-property' | 'effect-call' | 'mutation' | 'throw';
+/**
+ * One control-flow unit of the body. `jump` and `declaration` units are
+ * placed but not counted: they carry no analyzable data flow.
+ */
+type SliceCohesionUnitKind = 'statement' | 'predicate' | 'return' | 'throw' | 'jump' | 'declaration';
+/** `signal` when the split is backed by a complete local model and a narrow extraction; `support` when a reviewer must confirm it. */
+type SliceCohesionActionTier = 'signal' | 'support';
+/**
+ * What kind of body was sliced. A React component or hook is bound by hook
+ * rules, and an orchestration root sequences independent operations by
+ * design, so each is read differently from a plain calculation.
+ */
+type SliceCohesionArchetype = 'calculation' | 'react-component' | 'react-hook' | 'orchestration';
+/**
+ * What an extracted cluster would be: a pure calculation, an operation that
+ * computes a result while awaiting or affecting the outside, a custom hook,
+ * or a sequence of effects.
+ */
+type SliceCohesionClusterKind = 'calculation' | 'operation' | 'hook' | 'effects';
+/** The largest qualifying cluster stays in place; the others are the extractions; the rest are below threshold. */
+type SliceCohesionClusterRole = 'remainder' | 'extraction' | 'below-threshold';
+interface SliceCohesionUnit {
+    index: number;
+    kind: SliceCohesionUnitKind;
+    startLine: number;
+    endLine: number;
+    label: string;
+}
+interface SliceCohesionOutput {
+    id: string;
+    kind: SliceCohesionOutputKind;
+    label: string;
+    /** Zero-based line of the first unit producing the output. */
+    line: number;
+    /** Counted units that produce this output; a function's return value merges every non-guard return statement. */
+    units: number[];
+    /** True when the output carries no computed value: an exit whose slice is only itself. */
+    guard: boolean;
+    /** True for a React hook call such as `useEffect`: a lifecycle effect rather than a plain call. */
+    hook: boolean;
+    /** Size of the computation slice: counted units reached backward through data edges and non-guard control edges. */
+    sliceSize: number;
+    /** Size of the full slice: counted units reached through data edges and every control edge, guards included. */
+    fullSliceSize: number;
+    /** The computation slice itself; present when the candidate was requested in detail. */
+    slice?: number[];
+    /** The full slice itself; present when the candidate was requested in detail. */
+    fullSlice?: number[];
+}
+interface SliceCohesionLineRange {
+    startLine: number;
+    endLine: number;
+}
+interface SliceCohesionCluster {
+    outputs: string[];
+    /** Counted units exclusive to this cluster after shared setup is removed. */
+    units: number[];
+    /** Zero-based line ranges covering the cluster's units. */
+    lineRanges: SliceCohesionLineRange[];
+    /**
+     * The parameters an extraction would take: function parameters, `this`,
+     * shared-setup bindings, and locals of an enclosing function the cluster
+     * reads. Imports, module-level names, globals, and JSX tags stay imports.
+     */
+    inputs: string[];
+    kind: SliceCohesionClusterKind;
+    role: SliceCohesionClusterRole;
+    /** Whether `inputs` is within the signal bound; the remainder never needs an interface. */
+    narrow: boolean;
+    /** Hook calls the cluster contains, for hook-candidate wording. */
+    hooks: string[];
+    /** True when every output in the cluster is a throw: validation, not a computation. */
+    guardOnly: boolean;
+}
+interface SliceCohesionMetrics {
+    /** Share of counted statements in every value output's computation slice (Ott and Thuss tightness). */
+    tightness: number;
+    /** Tightness over full slices, guards included. */
+    fullTightness: number;
+    /** Mean computation-slice size as a share of counted statements (Ott and Thuss coverage). */
+    sliceShare: number;
+    fullSliceShare: number;
+    /** Mean share of each computation slice that lies in the intersection of all of them (overlap). */
+    overlap: number;
+    /** Statements in every full slice. */
+    superglue: number;
+    /** Statements in two or more full slices. */
+    glue: number;
+}
+interface SliceCohesionCoverage {
+    /** `partial` only when a gap can drop dependencies; conservative approximations keep `complete`. */
+    status: 'complete' | 'partial';
+    /**
+     * What `complete` covers: the function-local flow model. Runtime order,
+     * callee behavior, and framework scheduling are outside it.
+     */
+    model: 'function-local-flow';
+    basis: 'typescript-local-flow-backward-slices';
+    unsupported: string[];
+    /** Flow edges used whose strength is candidate rather than exact. */
+    candidateEdges: number;
+    /** Candidate edges are treated as dependencies, so they can merge clusters but never separate them. */
+    candidateEdgeEffect: 'merge-only';
+}
+interface SliceCohesionCandidate {
+    symbol: string;
+    shortName: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    archetype: SliceCohesionArchetype;
+    /** True under a scripts, tools, bin, or migrations directory: operational code that legitimately sequences steps. */
+    operational: boolean;
+    /** Every body unit; present when the candidate was requested in detail. */
+    units?: SliceCohesionUnit[];
+    /** Units that carry data flow: statements, predicates, returns, and throws. */
+    statementCount: number;
+    outputs: SliceCohesionOutput[];
+    metrics: SliceCohesionMetrics;
+    /** Independent computations, largest first. */
+    clusters: SliceCohesionCluster[];
+    /** Value outputs that depend on shared setup only; they belong to whichever function keeps the setup. */
+    preambleOnlyOutputs: string[];
+    /** Counted units derived only from inputs and read by several outputs. */
+    preamble: number[];
+    /** Counted units no output depends on. */
+    orphans: number[];
+    /** Statements in the extraction clusters: what could leave the function while the largest computation stays. */
+    separableStatements: number;
+    splitCandidate: boolean;
+    actionTier: SliceCohesionActionTier;
+    tierReason: string;
+    evidenceReasons: string[];
+    recommendation: string;
+    coverage: SliceCohesionCoverage;
+}
+interface SourceFileCache {
+    files: Map<string, TypeScript.SourceFile | null>;
+}
+/**
+ * Measure functional cohesion from backward slices.
+ *
+ * For each thing a function hands to the outside world (its return value,
+ * each property of a returned object, an effect call, a write to state it
+ * does not own, a throw) the analysis takes the backward slice over the
+ * local definition-use and control-dependence graph. Outputs whose slices
+ * share statements belong to one computation; outputs whose slices are
+ * disjoint are separate local computations that happen to live in one
+ * body. Statements derived only from the inputs and read by several
+ * outputs are shared setup, not glue. The partition is the finding: the
+ * largest computation stays in place and every other qualifying cluster is
+ * an extraction with its parameters already named.
+ */
+declare function sliceCohesion(db: ScipDatabase, opts?: {
+    scope?: string;
+    symbol?: string;
+    minLoc?: number;
+    minStatements?: number;
+    minClusterUnits?: number;
+    limit?: number;
+    scanLimit?: number;
+    /** Include every unit and slice in each candidate; defaults to true for a targeted symbol. */
+    detail?: boolean;
+    onProgress?: (progress: CandidateScanProgress) => void;
+    /** Receives the scan counters, so a caller can report how much of the repository the result covers. */
+    onProfile?: (counters: CandidatePipelineCounters) => void;
+}): SliceCohesionCandidate[];
+/**
+ * Slice one callable. Null when the file is not TypeScript-like, the
+ * compiler is unavailable, no function-like body sits inside the
+ * definition range, or the flow analysis reports no support at all.
+ */
+declare function sliceCohesionForDefinition(db: ScipDatabase, definition: IndexedDefinition, opts?: {
+    minStatements?: number;
+    minClusterUnits?: number;
+    detail?: boolean;
+}, cache?: SourceFileCache): SliceCohesionCandidate | null;
+
+export { type SliceCohesionActionTier, type SliceCohesionArchetype, type SliceCohesionCandidate, type SliceCohesionCluster, type SliceCohesionClusterKind, type SliceCohesionClusterRole, type SliceCohesionCoverage, type SliceCohesionLineRange, type SliceCohesionMetrics, type SliceCohesionOutput, type SliceCohesionOutputKind, type SliceCohesionUnit, type SliceCohesionUnitKind, sliceCohesion, sliceCohesionForDefinition };

package/dist/queries/slice-cohesion.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-BUTWYEPH.js";import"../chunk-NOWINRRN.js";import"../chunk-N2WN6I3L.js";import"../chunk-BOJ5SVE2.js";import"../chunk-6LSEIIF7.js";import"../chunk-BGBBVSH4.js";import"../chunk-36SGVCGX.js";import"../chunk-AGWFSTXC.js";import"../chunk-P5XHIJHI.js";import"../chunk-73AAKPUC.js";import"../chunk-KZBJWZJB.js";import"../chunk-4WTUBQ36.js";import"../chunk-NZAXKGRL.js";import"../chunk-KK7GPALL.js";import"../chunk-YNQCGEQE.js";import"../chunk-FMRN2TRL.js";import"../chunk-DA7RPPDF.js";import"../chunk-4WCUBZU3.js";import"../chunk-E3FDPXZK.js";import"../chunk-DHEQMPLW.js";import"../chunk-KHWRRPV4.js";import"../chunk-72AD6ZRR.js";import"../chunk-YUKYB54I.js";import"../chunk-GCKCF5FL.js";import"../chunk-DVFP6PZI.js";import"../chunk-5D2LVK7O.js";import"../chunk-7WTPQ4NX.js";import"../chunk-FVULPZDF.js";import"../chunk-D3FDISIC.js";import"../chunk-A2IIGFMJ.js";import"../chunk-PH52RA7D.js";import"../chunk-GVWX5T43.js";import"../chunk-T6DK3ZP7.js";import"../chunk-5TNQJUR2.js";export{a as sliceCohesion,b as sliceCohesionForDefinition};
+//# sourceMappingURL=slice-cohesion.js.map