@opensip-cli/core 0.1.0

package/dist/languages/__tests__/workspace-unit-contract.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, expectTypeOf, vi } from 'vitest';
+const FAKE_ROOT = '/var/fixture-root';
+const FAKE_PKG_DIR = '/var/fixture-root/packages/a';
+const FAKE_PKG_TSCONFIG = '/var/fixture-root/packages/a/tsconfig.json';
+const FAKE_SUB_DIR = '/var/fixture-root/sub';
+describe('discoverWorkspaceUnits contract', () => {
+    it('compiles for an adapter that omits discoverWorkspaceUnits', () => {
+        const adapter = {
+            id: 'no-workspace',
+            fileExtensions: ['.x'],
+            parse: () => null,
+            stripStrings: (s) => s,
+            stripComments: (s) => s,
+        };
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(adapter.discoverWorkspaceUnits).toBeUndefined();
+    });
+    it('compiles for an adapter that returns an empty unit list', async () => {
+        const adapter = {
+            id: 'empty-workspace',
+            fileExtensions: ['.x'],
+            parse: () => null,
+            stripStrings: (s) => s,
+            stripComments: (s) => s,
+            discoverWorkspaceUnits: vi.fn().mockResolvedValue([]),
+        };
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(adapter.discoverWorkspaceUnits).toBeTypeOf('function');
+        const units = await adapter.discoverWorkspaceUnits?.(FAKE_ROOT);
+        expect(units).toEqual([]);
+    });
+    it('compiles for an adapter that returns one WorkspaceUnit', async () => {
+        const unit = {
+            id: 'pkg-a',
+            rootDir: FAKE_PKG_DIR,
+            configPath: FAKE_PKG_TSCONFIG,
+        };
+        const adapter = {
+            id: 'has-workspace',
+            fileExtensions: ['.x'],
+            parse: () => null,
+            stripStrings: (s) => s,
+            stripComments: (s) => s,
+            // eslint-disable-next-line @typescript-eslint/require-await
+            discoverWorkspaceUnits: async () => [unit],
+        };
+        const units = await adapter.discoverWorkspaceUnits?.(FAKE_ROOT);
+        expect(units).toHaveLength(1);
+        expect(units?.[0]?.id).toBe('pkg-a');
+        expect(units?.[0]?.rootDir).toBe(FAKE_PKG_DIR);
+        expect(units?.[0]?.configPath).toBe(FAKE_PKG_TSCONFIG);
+    });
+    it('makes configPath optional on WorkspaceUnit', () => {
+        const unit = {
+            id: 'no-config',
+            rootDir: FAKE_SUB_DIR,
+        };
+        expect(unit.configPath).toBeUndefined();
+        expectTypeOf().toHaveProperty('id').toEqualTypeOf();
+        expectTypeOf().toHaveProperty('rootDir').toEqualTypeOf();
+    });
+    it('typechecks the discoverWorkspaceUnits signature', () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});
+//# sourceMappingURL=workspace-unit-contract.test.js.map

package/dist/languages/__tests__/workspace-unit-contract.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-unit-contract.test.js","sourceRoot":"","sources":["../../../src/languages/__tests__/workspace-unit-contract.test.ts"],"names":[],"mappings":"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"}

package/dist/languages/adapter.d.ts

@@ -0,0 +1,66 @@
+import type { GenericFunction, Import, Location } from './generic-types.js';
+import type { WorkspaceUnit } from './workspace-unit.js';
+/**
+ * Minimal cross-language query primitives. Each adapter implements
+ * whichever of these it can support efficiently.
+ */
+export interface LanguageQueryAPI<TTree, TNode> {
+    findFunctions(tree: TTree): readonly GenericFunction<TNode>[];
+    findImports(tree: TTree): readonly Import[];
+    findCallsTo(tree: TTree, name: string): readonly TNode[];
+    findStringLiterals(tree: TTree): readonly {
+        readonly value: string;
+        readonly location: Location;
+    }[];
+    getLocation(tree: TTree, node: TNode): Location;
+    getText(tree: TTree, node: TNode): string;
+}
+/**
+ * A LanguageAdapter is the contract that every language pack implements.
+ * TTree/TNode are opaque to core — passed through to checks.
+ */
+export interface LanguageAdapter<TTree = unknown, TNode = unknown> {
+    /** Stable identifier matched against scope.languages in checks and languages: in targets. */
+    readonly id: string;
+    /** Lowercase extensions including the leading dot, e.g. ['.rs'] or ['.ts', '.tsx']. */
+    readonly fileExtensions: readonly string[];
+    /**
+     * Optional aliases — e.g. `['rs']` for Rust, `['c']` for the cpp
+     * adapter. The registry indexes these alongside `id` and consults
+     * them through {@link LanguageRegistry.canonicalize}, so a target
+     * declared with `languages: ['c']` matches a check scoped to `cpp`.
+     */
+    readonly aliases?: readonly string[];
+    /** Parse a file's text into the adapter's native tree. Returns null on parse failure. */
+    parse(content: string, filePath: string): TTree | null;
+    /** Replace string literal content with whitespace of equal length. */
+    stripStrings(content: string): string;
+    /** Replace both string literals AND comments with whitespace of equal length. */
+    stripComments(content: string): string;
+    /** Optional generic query layer for cross-language checks. */
+    readonly query?: LanguageQueryAPI<TTree, TNode>;
+    /**
+     * Optional async warmup (e.g. for tree-sitter WASM init). Reserved on the
+     * contract for adapters that need a one-time async init pass. No bundled
+     * adapter declares it today and the CLI bootstrap does NOT invoke it yet —
+     * treat it as forward-compatible: a future adapter can opt in without a
+     * contract change.
+     */
+    warmup?(): Promise<void>;
+    /**
+     * Optional workspace discovery. When implemented, returns the units
+     * the `graph --workspace` fan-out should target — one TS package per
+     * tsconfig.json, one Cargo member per `[workspace.members]` entry, etc.
+     *
+     * Adapters that have no workspace concept (or haven't implemented this
+     * yet) omit the method; the CLI treats absence as an empty list. If
+     * every detected adapter omits it AND the user passes `--workspace`,
+     * the CLI errors with a message naming the language(s).
+     *
+     * `rootDir` is the absolute project root (the CLI's `--cwd` or
+     * detection root). Implementations MUST return absolute paths in
+     * `rootDir`; relative paths break the spawn step downstream.
+     */
+    discoverWorkspaceUnits?(rootDir: string): Promise<readonly WorkspaceUnit[]>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/languages/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/languages/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAC5C,aAAa,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;IAC9D,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAAC;IAC5C,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,KAAK,EAAE,CAAC;IACzD,kBAAkB,CAChB,IAAI,EAAE,KAAK,GACV,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;KAAE,EAAE,CAAC;IACtE,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,QAAQ,CAAC;IAChD,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAC/D,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,uFAAuF;IACvF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAErC,yFAAyF;IACzF,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC;IAEvD,sEAAsE;IACtE,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtC,iFAAiF;IACjF,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAEvC,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;;;;;;;;OAaG;IACH,sBAAsB,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC,CAAC;CAC7E"}

package/dist/languages/adapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.js.map

package/dist/languages/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/languages/adapter.ts"],"names":[],"mappings":""}

package/dist/languages/content-filter-dispatch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Adapter-driven content filter dispatch.
+ *
+ * Resolves the LanguageAdapter for a file's extension and applies its
+ * stripStrings or stripComments method. Falls back to returning content
+ * unchanged when no adapter is registered for the extension.
+ *
+ * This is the boundary that lets cross-language checks (in
+ * @opensip-cli/checks-universal and similar) consume "code only,
+ * strings stripped" or "code only, strings + comments stripped" without
+ * knowing which language a file is in.
+ */
+/**
+ * Test-only reset of the one-shot degradation-warning guard. Production never
+ * calls this; tests use it to assert the warn-once behavior deterministically
+ * regardless of cross-test ordering.
+ */
+export declare function resetContentFilterWarningForTests(): void;
+/**
+ * Content filter modes a check can request:
+ *  - 'raw' / 'none': pass content through unchanged
+ *  - 'strip-strings': string literal content replaced with whitespace
+ *  - 'strip-strings-and-comments': both string literals and comments replaced
+ */
+export type ContentFilterMode = 'strip-strings' | 'strip-strings-and-comments' | 'none' | 'raw';
+/**
+ * Apply a content filter to file content, dispatching to the
+ * LanguageAdapter that owns the file extension.
+ *
+ * When no adapter is registered for the file's extension, returns
+ * the raw content unchanged. This preserves backward compatibility:
+ * callers that previously processed unknown-language files (JSON,
+ * YAML, plain text) keep getting raw content rather than crashing.
+ */
+export declare function applyContentFilter(filePath: string, content: string, mode: ContentFilterMode): string;
+//# sourceMappingURL=content-filter-dispatch.d.ts.map

package/dist/languages/content-filter-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-filter-dispatch.d.ts","sourceRoot":"","sources":["../../src/languages/content-filter-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH;;;;GAIG;AACH,wBAAgB,iCAAiC,IAAI,IAAI,CAExD;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG,4BAA4B,GAAG,MAAM,GAAG,KAAK,CAAC;AAEhG;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,iBAAiB,GACtB,MAAM,CAqCR"}

package/dist/languages/content-filter-dispatch.js

@@ -0,0 +1,75 @@
+/**
+ * @fileoverview Adapter-driven content filter dispatch.
+ *
+ * Resolves the LanguageAdapter for a file's extension and applies its
+ * stripStrings or stripComments method. Falls back to returning content
+ * unchanged when no adapter is registered for the extension.
+ *
+ * This is the boundary that lets cross-language checks (in
+ * @opensip-cli/checks-universal and similar) consume "code only,
+ * strings stripped" or "code only, strings + comments stripped" without
+ * knowing which language a file is in.
+ */
+import { logger } from '../lib/logger.js';
+import { currentScope } from '../lib/run-scope.js';
+/**
+ * One-shot guard so the degradation warning fires at most once per process.
+ * The condition is process-global (a missing scope or duplicate core affects
+ * every subsequent call identically), so repeating the warning adds only noise.
+ */
+let warnedFilterDegraded = false;
+/**
+ * Test-only reset of the one-shot degradation-warning guard. Production never
+ * calls this; tests use it to assert the warn-once behavior deterministically
+ * regardless of cross-test ordering.
+ */
+export function resetContentFilterWarningForTests() {
+    warnedFilterDegraded = false;
+}
+/**
+ * Apply a content filter to file content, dispatching to the
+ * LanguageAdapter that owns the file extension.
+ *
+ * When no adapter is registered for the file's extension, returns
+ * the raw content unchanged. This preserves backward compatibility:
+ * callers that previously processed unknown-language files (JSON,
+ * YAML, plain text) keep getting raw content rather than crashing.
+ */
+export function applyContentFilter(filePath, content, mode) {
+    if (mode === 'none' || mode === 'raw')
+        return content;
+    const scope = currentScope();
+    if (!scope) {
+        // No active RunScope at all. Two cases land here:
+        //   1. A unit test calling `check.run` directly (documented, benign).
+        //   2. A DUPLICATE @opensip-cli/core instance — the engine DID call
+        //      runWithScope, but on a different core copy than the one running
+        //      this code, so its AsyncLocalStorage store is invisible here. This
+        //      happens when a globally-installed CLI loads check packs from a
+        //      project that also vendors @opensip-cli packages.
+        // Either way we can't strip safely, so we degrade to raw — but a check
+        // that asked for stripping and silently gets raw will match patterns
+        // inside string literals/comments (false positives). Warn once so the
+        // degradation is observable instead of mysterious. (Case 2 is also
+        // refused outright at pack-load time; see discovery's single-core guard.)
+        if (!warnedFilterDegraded) {
+            warnedFilterDegraded = true;
+            logger.warn('content filter degraded to raw — no active run scope', {
+                evt: 'core.content_filter.degraded',
+                module: 'core:content-filter',
+                mode,
+                hint: 'A check requested string/comment stripping but no RunScope is active. If you are running a globally-installed opensip-cli inside a project that also installs @opensip-cli packages, duplicate core instances split the scope — prefer the project-local CLI (e.g. `pnpm fit`). Results may contain false positives.',
+            });
+        }
+        return content;
+    }
+    const adapter = scope.languages.forFile(filePath);
+    if (!adapter) {
+        // Scope is present but no adapter owns this extension — a genuinely
+        // unknown language (JSON/YAML/plain text). Returning raw is correct and
+        // expected here, so this path stays silent.
+        return content;
+    }
+    return mode === 'strip-strings' ? adapter.stripStrings(content) : adapter.stripComments(content);
+}
+//# sourceMappingURL=content-filter-dispatch.js.map

package/dist/languages/content-filter-dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-filter-dispatch.js","sourceRoot":"","sources":["../../src/languages/content-filter-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;GAIG;AACH,IAAI,oBAAoB,GAAG,KAAK,CAAC;AAEjC;;;;GAIG;AACH,MAAM,UAAU,iCAAiC;IAC/C,oBAAoB,GAAG,KAAK,CAAC;AAC/B,CAAC;AAUD;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAAgB,EAChB,OAAe,EACf,IAAuB;IAEvB,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,OAAO,CAAC;IAEtD,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;IAC7B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,kDAAkD;QAClD,sEAAsE;QACtE,oEAAoE;QACpE,uEAAuE;QACvE,yEAAyE;QACzE,sEAAsE;QACtE,wDAAwD;QACxD,uEAAuE;QACvE,qEAAqE;QACrE,sEAAsE;QACtE,mEAAmE;QACnE,0EAA0E;QAC1E,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC1B,oBAAoB,GAAG,IAAI,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,sDAAsD,EAAE;gBAClE,GAAG,EAAE,8BAA8B;gBACnC,MAAM,EAAE,qBAAqB;gBAC7B,IAAI;gBACJ,IAAI,EAAE,sTAAsT;aAC7T,CAAC,CAAC;QACL,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,oEAAoE;QACpE,wEAAwE;QACxE,4CAA4C;QAC5C,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,OAAO,IAAI,KAAK,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AACnG,CAAC"}

package/dist/languages/generic-types.d.ts

@@ -0,0 +1,22 @@
+/** Shared types used by the cross-language query API. */
+export interface Location {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+/** Cross-language import descriptor: specifier, imported names, and source location. */
+export interface Import {
+    /** The import specifier as written in source (e.g. './foo', 'std::fs', '"fmt"') */
+    readonly specifier: string;
+    /** Imported names where the language supports named imports; empty otherwise */
+    readonly names: readonly string[];
+    readonly location: Location;
+}
+/** Cross-language function descriptor parameterised by the adapter's native AST node type. */
+export interface GenericFunction<TNode> {
+    readonly name: string | null;
+    readonly location: Location;
+    /** The native AST node, opaque to core */
+    readonly node: TNode;
+}
+//# sourceMappingURL=generic-types.d.ts.map

package/dist/languages/generic-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-types.d.ts","sourceRoot":"","sources":["../../src/languages/generic-types.ts"],"names":[],"mappings":"AAAA,yDAAyD;AAEzD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wFAAwF;AACxF,MAAM,WAAW,MAAM;IACrB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED,8FAA8F;AAC9F,MAAM,WAAW,eAAe,CAAC,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACtB"}

package/dist/languages/generic-types.js

@@ -0,0 +1,3 @@
+/** Shared types used by the cross-language query API. */
+export {};
+//# sourceMappingURL=generic-types.js.map

package/dist/languages/generic-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-types.js","sourceRoot":"","sources":["../../src/languages/generic-types.ts"],"names":[],"mappings":"AAAA,yDAAyD"}

package/dist/languages/index.d.ts

@@ -0,0 +1,12 @@
+export type { LanguageAdapter, LanguageQueryAPI } from './adapter.js';
+export type { GenericFunction, Import, Location } from './generic-types.js';
+export type { WorkspaceUnit } from './workspace-unit.js';
+export { LanguageRegistry } from './registry.js';
+export { LanguageParseCache, initParseCache, clearParseCache, getParseTree, getParseTreeForFile, } from './parse-cache.js';
+export { applyContentFilter, type ContentFilterMode } from './content-filter-dispatch.js';
+export { RECOGNIZED_NON_CODE_FORMATS, isRecognizedNonCodeFormat } from './non-code-formats.js';
+export { applyRegions, buildLineStarts, isIdentChar, makeStripper, scanBlockCommentNesting, scanBlockCommentNonNesting, scanCharLiteral, scanLineComment, scanRegularString, } from './strip-utils.js';
+export type { Region, RegStrResult, ScanResult, Stripper, ScanCharLiteralOptions, ScanCharLiteralResult, ScanCommentResult, ScanLineCommentOptions, ScanNestingBlockCommentResult, ScanRegularStringOptions, } from './strip-utils.js';
+export { buildMinimalTextTree } from './text-tree.js';
+export type { MinimalTextTree } from './text-tree.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/languages/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC5E,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC1F,OAAO,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACL,YAAY,EACZ,eAAe,EACf,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,MAAM,EACN,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,6BAA6B,EAC7B,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/languages/index.js

@@ -0,0 +1,7 @@
+export { LanguageRegistry } from './registry.js';
+export { LanguageParseCache, initParseCache, clearParseCache, getParseTree, getParseTreeForFile, } from './parse-cache.js';
+export { applyContentFilter } from './content-filter-dispatch.js';
+export { RECOGNIZED_NON_CODE_FORMATS, isRecognizedNonCodeFormat } from './non-code-formats.js';
+export { applyRegions, buildLineStarts, isIdentChar, makeStripper, scanBlockCommentNesting, scanBlockCommentNonNesting, scanCharLiteral, scanLineComment, scanRegularString, } from './strip-utils.js';
+export { buildMinimalTextTree } from './text-tree.js';
+//# sourceMappingURL=index.js.map

package/dist/languages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/languages/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAA0B,MAAM,8BAA8B,CAAC;AAC1F,OAAO,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACL,YAAY,EACZ,eAAe,EACf,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAa1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/languages/non-code-formats.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Recognized non-code format tags.
+ *
+ * The `languages:` field on a target (and the matching `scope.languages`
+ * on a check) is a *matching dimension* — it routes files to checks via
+ * `findByScope`. A SUBSET of those tags also have a registered
+ * {@link LanguageAdapter} that can parse the file and strip its
+ * strings/comments for content-aware checks.
+ *
+ * Structured-data and markup formats (JSON, YAML, Markdown, …) are
+ * legitimate matching tags but have NO adapter by design: there is no
+ * meaningful "strip strings/comments" pass for them (stripping JSON
+ * "strings" would blank out object keys that checks like
+ * `cluster-coupling` and `table-access-ownership` match on), so the
+ * content filter correctly returns them raw.
+ *
+ * This set names those intentional adapter-less tags so config
+ * validation can tell them apart from a genuine typo. A target declaring
+ * `languages: ['json']` is fine; `languages: ['pythonn']` is a mistake.
+ */
+/**
+ * Format tags that are valid `languages:` matching tags but intentionally
+ * have no content-filter adapter. Files in these formats scan as raw
+ * content — there is nothing to strip.
+ *
+ * Lowercase, canonical. Extend this set when a new adapter-less format
+ * tag becomes a legitimate scope dimension (the alternative is to ship a
+ * real {@link LanguageAdapter} for it).
+ */
+export declare const RECOGNIZED_NON_CODE_FORMATS: ReadonlySet<string>;
+/**
+ * True when `tag` is a recognized non-code format — a valid scope tag
+ * that has no content-filter adapter by design. Comparison is
+ * case-insensitive.
+ */
+export declare function isRecognizedNonCodeFormat(tag: string): boolean;
+//# sourceMappingURL=non-code-formats.d.ts.map

package/dist/languages/non-code-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-code-formats.d.ts","sourceRoot":"","sources":["../../src/languages/non-code-formats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,CAM1D,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9D"}

package/dist/languages/non-code-formats.js

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Recognized non-code format tags.
+ *
+ * The `languages:` field on a target (and the matching `scope.languages`
+ * on a check) is a *matching dimension* — it routes files to checks via
+ * `findByScope`. A SUBSET of those tags also have a registered
+ * {@link LanguageAdapter} that can parse the file and strip its
+ * strings/comments for content-aware checks.
+ *
+ * Structured-data and markup formats (JSON, YAML, Markdown, …) are
+ * legitimate matching tags but have NO adapter by design: there is no
+ * meaningful "strip strings/comments" pass for them (stripping JSON
+ * "strings" would blank out object keys that checks like
+ * `cluster-coupling` and `table-access-ownership` match on), so the
+ * content filter correctly returns them raw.
+ *
+ * This set names those intentional adapter-less tags so config
+ * validation can tell them apart from a genuine typo. A target declaring
+ * `languages: ['json']` is fine; `languages: ['pythonn']` is a mistake.
+ */
+/**
+ * Format tags that are valid `languages:` matching tags but intentionally
+ * have no content-filter adapter. Files in these formats scan as raw
+ * content — there is nothing to strip.
+ *
+ * Lowercase, canonical. Extend this set when a new adapter-less format
+ * tag becomes a legitimate scope dimension (the alternative is to ship a
+ * real {@link LanguageAdapter} for it).
+ */
+export const RECOGNIZED_NON_CODE_FORMATS = new Set([
+    'json',
+    'yaml',
+    'markdown',
+    'toml',
+    'plaintext',
+]);
+/**
+ * True when `tag` is a recognized non-code format — a valid scope tag
+ * that has no content-filter adapter by design. Comparison is
+ * case-insensitive.
+ */
+export function isRecognizedNonCodeFormat(tag) {
+    return RECOGNIZED_NON_CODE_FORMATS.has(tag.toLowerCase());
+}
+//# sourceMappingURL=non-code-formats.js.map

package/dist/languages/non-code-formats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-code-formats.js","sourceRoot":"","sources":["../../src/languages/non-code-formats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAwB,IAAI,GAAG,CAAC;IACtE,MAAM;IACN,MAAM;IACN,UAAU;IACV,MAAM;IACN,WAAW;CACZ,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,GAAW;IACnD,OAAO,2BAA2B,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;AAC5D,CAAC"}

package/dist/languages/parse-cache-class.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview `LanguageParseCache` class definition.
+ *
+ * Lives in its own module so `RunScope` (which holds a default
+ * `LanguageParseCache` instance) and the module-level helpers in
+ * `parse-cache.ts` (which read `currentScope()`) don't form an
+ * import cycle. The class has zero deps on `run-scope.ts`; the helpers
+ * import the class from here, and `run-scope.ts` also imports the
+ * class from here.
+ */
+import type { LanguageAdapter } from './adapter.js';
+/**
+ * Fast content fingerprint for the parse-cache key (FNV-1a 64-bit over the FULL
+ * content + length). Distinguishes raw source from same-length filtered variants
+ * (`filterContent` blanks string/comment regions to spaces, preserving length),
+ * so an AST check that needs raw source never receives a strings-stripped tree.
+ *
+ * 64-bit (vs prior 32-bit) materially reduces the chance of a silent collision
+ * between two *different* files of the same length under the same language
+ * adapter (the path component helps, but same-length generated/index/etc files
+ * are common in real trees). The hash is still cheap O(n) relative to parsing.
+ * The trailing length suffix provides an extra guard.
+ */
+export declare function fingerprintContent(content: string): string;
+/**
+ * Per-instance parse cache. Each instance owns its own parse-tree
+ * `Map`, a sibling `filteredContent` `Map` (for language-specific
+ * filtered-content caching keyed by raw content), and (optionally) an
+ * auto-clear timer that fires `AUTO_CLEAR_MS` after the cache is
+ * started.
+ *
+ * The two maps live together because they share the same lifecycle —
+ * a fresh run starts both at empty, a `dispose()` clears both, and the
+ * auto-clear timer drops both. The maps use different keys (parse-tree
+ * map is keyed by adapter+filePath+fingerprint; filtered-content map
+ * is keyed by raw content) because the two upstream call paths use
+ * different identities.
+ */
+export declare class LanguageParseCache {
+    private readonly cache;
+    /**
+     * Language-specific filtered-content cache. Keyed by raw content
+     * string (no adapter or file path prefix) because the
+     * `filterContent(content)` API in `@opensip-cli/lang-typescript`
+     * is content-only. Phase 6 Task 6.4 moved this off a separate
+     * module-level Map; the merge is by lifecycle, not by key shape.
+     */
+    readonly filteredContent: Map<string, unknown>;
+    private autoClearTimer;
+    /**
+     * Start the auto-clear timer. Calling this twice resets the timer.
+     * Production code goes through `initParseCache()` (which targets the
+     * module-level instance); tests call this directly on a fresh
+     * instance. The timer is `unref`'d so it doesn't keep the process
+     * alive; `dispose()` clears it deterministically.
+     */
+    startAutoClear(): void;
+    getOrParse<TTree>(adapter: LanguageAdapter<TTree>, filePath: string, content: string): TTree | null;
+    clear(): void;
+    /**
+     * Clear the cache and any pending auto-clear timer. Tests that
+     * construct a fresh `LanguageParseCache()` should call `dispose()`
+     * before the test exits so the runner doesn't see a lingering
+     * timer handle.
+     */
+    dispose(): void;
+    get size(): number;
+}
+//# sourceMappingURL=parse-cache-class.d.ts.map

package/dist/languages/parse-cache-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cache-class.d.ts","sourceRoot":"","sources":["../../src/languages/parse-cache-class.ts"],"names":[],"mappings":"AACA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AASpD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,uBAA8B;IACtD,OAAO,CAAC,cAAc,CAA8C;IAEpE;;;;;;OAMG;IACH,cAAc,IAAI,IAAI;IAUtB,UAAU,CAAC,KAAK,EACd,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,KAAK,GAAG,IAAI;IAmBf,KAAK,IAAI,IAAI;IAKb;;;;;OAKG;IACH,OAAO,IAAI,IAAI;IASf,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/languages/parse-cache-class.js

@@ -0,0 +1,135 @@
+// @fitness-ignore-file toctou-race-condition -- synchronous Map.get/set in single-threaded Node.js runtime; no async gap between read and write
+/**
+ * @fileoverview `LanguageParseCache` class definition.
+ *
+ * Lives in its own module so `RunScope` (which holds a default
+ * `LanguageParseCache` instance) and the module-level helpers in
+ * `parse-cache.ts` (which read `currentScope()`) don't form an
+ * import cycle. The class has zero deps on `run-scope.ts`; the helpers
+ * import the class from here, and `run-scope.ts` also imports the
+ * class from here.
+ */
+// 10 minutes — the cache is regenerated on every fitness run, so 10
+// minutes of staleness is the worst case for a check author who edits
+// a source file between runs in a long-lived process. Short enough to
+// avoid serving a tree that no longer matches the file on disk; long
+// enough that consecutive runs in a watch loop hit the cache.
+const AUTO_CLEAR_MS = 10 * 60 * 1000;
+/**
+ * Fast content fingerprint for the parse-cache key (FNV-1a 64-bit over the FULL
+ * content + length). Distinguishes raw source from same-length filtered variants
+ * (`filterContent` blanks string/comment regions to spaces, preserving length),
+ * so an AST check that needs raw source never receives a strings-stripped tree.
+ *
+ * 64-bit (vs prior 32-bit) materially reduces the chance of a silent collision
+ * between two *different* files of the same length under the same language
+ * adapter (the path component helps, but same-length generated/index/etc files
+ * are common in real trees). The hash is still cheap O(n) relative to parsing.
+ * The trailing length suffix provides an extra guard.
+ */
+export function fingerprintContent(content) {
+    // FNV-1a 64-bit constants (big-endian words not needed; BigInt keeps it simple
+    // and portable, and this is only used for cache keys).
+    const FNV_OFFSET = 0xcbf29ce484222325n;
+    const FNV_PRIME = 0x100000001b3n;
+    let hash = FNV_OFFSET;
+    // Iterate over Unicode code points (not UTF-16 code units). String iteration
+    // (`for...of`) yields full code points, correctly handling surrogate pairs
+    // (astral-plane characters such as emoji, certain CJK, mathematical symbols, etc.).
+    // Using codePointAt on individual code units previously produced incorrect
+    // fingerprints (and thus wrong/missed cache hits) for any content containing
+    // characters outside the BMP.
+    for (const char of content) {
+        const cp = char.codePointAt(0) ?? 0;
+        hash ^= BigInt(cp);
+        hash = (hash * FNV_PRIME) & 0xffffffffffffffffn; // keep to 64 bits
+    }
+    // toString(36) is compact; prefix with 'f64:' so readers know the scheme.
+    // The length suffix is intentionally UTF-16 code-unit length (content.length)
+    // for compatibility with filterContent (same-length string/comment blanks).
+    return `f64:${hash.toString(36)}:${String(content.length)}`;
+}
+/**
+ * Per-instance parse cache. Each instance owns its own parse-tree
+ * `Map`, a sibling `filteredContent` `Map` (for language-specific
+ * filtered-content caching keyed by raw content), and (optionally) an
+ * auto-clear timer that fires `AUTO_CLEAR_MS` after the cache is
+ * started.
+ *
+ * The two maps live together because they share the same lifecycle —
+ * a fresh run starts both at empty, a `dispose()` clears both, and the
+ * auto-clear timer drops both. The maps use different keys (parse-tree
+ * map is keyed by adapter+filePath+fingerprint; filtered-content map
+ * is keyed by raw content) because the two upstream call paths use
+ * different identities.
+ */
+export class LanguageParseCache {
+    cache = new Map();
+    /**
+     * Language-specific filtered-content cache. Keyed by raw content
+     * string (no adapter or file path prefix) because the
+     * `filterContent(content)` API in `@opensip-cli/lang-typescript`
+     * is content-only. Phase 6 Task 6.4 moved this off a separate
+     * module-level Map; the merge is by lifecycle, not by key shape.
+     */
+    filteredContent = new Map();
+    autoClearTimer = null;
+    /**
+     * Start the auto-clear timer. Calling this twice resets the timer.
+     * Production code goes through `initParseCache()` (which targets the
+     * module-level instance); tests call this directly on a fresh
+     * instance. The timer is `unref`'d so it doesn't keep the process
+     * alive; `dispose()` clears it deterministically.
+     */
+    startAutoClear() {
+        if (this.autoClearTimer)
+            clearTimeout(this.autoClearTimer);
+        this.autoClearTimer = setTimeout(() => {
+            this.cache.clear();
+            this.filteredContent.clear();
+            this.autoClearTimer = null;
+        }, AUTO_CLEAR_MS);
+        this.autoClearTimer.unref();
+    }
+    getOrParse(adapter, filePath, content) {
+        // Cache key fingerprints the FULL content so raw and code-only-filtered
+        // variants of the same file never collide. `filterContent` replaces stripped
+        // regions (string/comment text) with same-length spaces, so neither
+        // `content.length` nor a first-N-chars sample distinguishes them when the
+        // divergence is later in the file — a sampled key let an AST check that
+        // needs raw source receive a strings-stripped tree (blanked module
+        // specifiers), nondeterministically by check order. A full-content hash is
+        // cheap relative to parsing and removes that cross-contamination.
+        const key = `${adapter.id}:${filePath}:${fingerprintContent(content)}`;
+        const cached = this.cache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const tree = adapter.parse(content, filePath);
+        if (tree === null)
+            return null;
+        this.cache.set(key, tree);
+        return tree;
+    }
+    clear() {
+        this.cache.clear();
+        this.filteredContent.clear();
+    }
+    /**
+     * Clear the cache and any pending auto-clear timer. Tests that
+     * construct a fresh `LanguageParseCache()` should call `dispose()`
+     * before the test exits so the runner doesn't see a lingering
+     * timer handle.
+     */
+    dispose() {
+        this.cache.clear();
+        this.filteredContent.clear();
+        if (this.autoClearTimer) {
+            clearTimeout(this.autoClearTimer);
+            this.autoClearTimer = null;
+        }
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+//# sourceMappingURL=parse-cache-class.js.map