codebaseiq 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,349 @@
+# codebaseiq
+
+codebaseiq is a compiler-backed repository-understanding system for coding
+agents.
+
+A repository-understanding system turns indexed code facts into accurate,
+navigable abstractions of the systems in a codebase. Its essential service is
+structure-preserving compression: an agent can see the relevant regions and
+relationships before an edit, drill into several material regions together,
+and keep exact source identities for its plan without reading every
+implementation. codebaseiq differs from text search because it uses
+compiler-produced SCIP indexes: two matching words count as the same symbol
+only when the language tooling resolves them to the same definition. It also
+reports coverage gaps, so omitted evidence is not mistaken for evidence that a
+relationship does not exist.
+
+The tool helps an agent answer four practical questions:
+
+- What is this code connected to?
+- Which systems participate in this behavior from entry to final effect?
+- Who consumes it, and what could a change affect?
+- Does the repository declare a structural rule for this dependency?
+- Where do React, Vue, duplication, drift, complexity, or cleanup detectors
+  point to code worth inspecting?
+
+The agent still owns the task, plan, implementation, tests, and final judgment.
+codebaseiq does not create goals, act as an acceptance test, or decide that work
+is complete.
+
+## Install
+
+codebaseiq requires Node.js 22 or newer. Node.js 24 LTS is recommended.
+
+```bash
+npm install -g codebaseiq
+cd your-repository
+codebaseiq setup
+```
+
+Setup detects supported languages, installs or checks their indexers, builds
+the local index, installs the bundled skills, and writes concise agent guidance.
+When the repository declares valid architecture rules, setup also installs one
+checkout-local Stop hook that checks those rules after indexed source changes.
+It does not install a completion gate, pre-commit gate, or CI enforcement.
+
+Check a setup with:
+
+```bash
+codebaseiq doctor
+codebaseiq capabilities
+```
+
+## The normal workflow
+
+Use codebaseiq as the primary reading surface for indexed source. First name the
+few material repository facts the answer depends on. Locate exact referents with
+`search` for trustworthy text, `outline` for a known file, or `entrypoints` for
+an external callable surface. Then select exact symbols or file/line constructs
+and project only the relationship families and directions capable of establishing
+those facts. codebaseiq resolves identity, typed edges, evidence strength, provider
+support, and bounded coverage; it does not decide which facts matter to the task.
+
+```bash
+codebaseiq search 'work_session_stream_events'
+codebaseiq evidence \
+  --symbol 'appendWorkSessionStreamEvents' \
+  --edge execution \
+  --edge runtime \
+  --direction both \
+  --depth 2 \
+  --max-edges 32
+```
+
+Treat the evidence inventory, facts, calibration, coverage, and recovery paths as
+one contract. Missing output is not evidence of absence. If a material fact still
+requires implementation behavior, batch its exact constructs into `inspect --view
+behavior`. Use `code` only when exact syntax can change the decision. Do not reread
+source already rendered by either command, and do not expand unrelated frontiers.
+
+Before answering, audit the draft itself against the material claims. A fact
+seen in evidence but left implicit in the answer is not recovered. Copy returned
+file and line identities exactly rather than reconstructing citation paths.
+
+A broad literal is counted exactly and returned with recoverable structural scopes.
+Narrow only when a named material fact requires one of those scopes.
+
+`code` accepts up to 24 exact symbols, ranges, or indexed file paths. A file
+path returns its exported definitions—or its top-level definitions when the
+language has no explicit export surface—plus the file-local definitions they
+reference, then lists every omitted local definition as an exact range. This
+keeps the default source surface small without hiding what remains available.
+Use `--members all` only when the complete file matters. If a proposed packet
+would exceed the active output budget, `code` emits no partial source and
+prints exact complete-packet splits; narrow to the exact units still needed
+before deciding whether every split remains necessary.
+
+Start an unknown path with `search`; batch related text, symbol, and file-line
+anchors with `inspect`; use `evidence` when one symbol and its real uses are the
+center of the question. For tracked nonbinary repository content, keep
+exploration on codebaseiq. Native tools are for applying edits, running checks,
+binary content, or a specific unsupported gap that codebaseiq has explicitly
+reported.
+
+```bash
+codebaseiq search work_session_stream_events
+codebaseiq inspect --search sessionStreamEvents --search work_session_stream_events --view behavior
+codebaseiq evidence appendWorkSessionStreamEvents --include definition,references,callers,callees
+```
+
+`inspect --view behavior` returns the cheapest faithful syntax-derived view of
+each complete source unit. Compact units stay raw. Larger units become
+hierarchical outlines only when that representation is materially smaller;
+every source statement is represented, and unsupported or
+compression-sensitive statements are copied verbatim. Coverage reports the
+represented, copied, and omitted counts. Exact source can be requested for any
+unit whose complete implementation matters. `inspect --symbol` includes definitions,
+references, callers, callees, dependencies, and consumers by default.
+
+Search, location, and relationship evidence is deduplicated into one ranked
+packet. Exact locations and definitions rank first; later units must add new
+file, role, scope, symbol, or behavior coverage. A default packet materializes
+at most 12 matching lines per text selector, then applies a soft ceiling of 48
+units or 60,000 displayed-evidence characters without clipping a returned
+syntax unit. Its omission ledger groups everything withheld by scope and role,
+reports what each group contains, and gives an exact command for drilling into
+that group. Drill into several relevant groups together; use `--full` only when
+all omitted evidence can change the decision. Large rendered output from other
+commands can still use the universal byte-transport continuation printed by
+every command.
+
+Before a nonlocal change:
+
+```bash
+codebaseiq context RetryPolicy
+```
+
+`context` returns a bounded evidence packet for a symbol, file, or module. It
+combines definitions, references, calls, data flow, dependencies, consumers,
+change risk, history, suppressions, and possible reuse sites. A bounded packet
+is a deliberately limited result: it is useful for a decision but does not
+claim to contain every possible relationship.
+
+After a coherent edit:
+
+```bash
+codebaseiq diff-impact
+```
+
+`diff-impact` maps changed symbols to downstream consumers. It is a change map,
+not a pass/fail gate. The agent uses it with native tests and source inspection.
+
+When structure matters:
+
+```bash
+codebaseiq architecture
+```
+
+An architecture rule is repository policy that permits or forbids dependency
+edges between named file groups. Its defining trait is that it states a team
+constraint, not a detector guess. Rules live in `.codebaseiq.json` and can cover
+closed dependency rows, cycles, unresolved boundaries, fan-out, boundary size,
+and test placement.
+
+When cleanup or drift matters:
+
+```bash
+codebaseiq health --full
+```
+
+Health is a collection of repository analyses, not a correctness grade. It
+reports graph facts and heuristic candidates separately. A heuristic candidate
+is a source location selected by a pattern that may indicate a problem; the
+agent must read the source before treating it as a defect.
+
+## React and Vue
+
+React and Vue analysis remains a first-class part of the product.
+
+```bash
+codebaseiq react-component-duplicates --full
+codebaseiq react-hook-candidates --full
+codebaseiq react-large-component-pressure --full
+
+codebaseiq vue-component-duplicates --full
+codebaseiq vue-composable-candidates --full
+codebaseiq vue-large-view-pressure --full
+```
+
+These commands find repeated component structure, hook or composable behavior
+that may deserve reuse, and files carrying unusually broad responsibility.
+They tell an agent where to inspect and clean up. They do not order an automatic
+refactor: intentional variation and real framework constraints must survive.
+
+Vue repositories can add source facts when their indexer needs them:
+
+```bash
+codebaseiq augment-vue
+```
+
+## Cleanup and drift commands
+
+The health report is an overview. Focused commands expose the evidence behind
+particular kinds of pressure:
+
+```bash
+codebaseiq duplicate-bodies --full
+codebaseiq twin-drift --full
+codebaseiq recent-duplicates --full
+codebaseiq incomplete-migration --full
+codebaseiq doc-drift --full
+codebaseiq unused-params --full
+codebaseiq dead --full
+codebaseiq isolated --full
+codebaseiq cycles --full
+codebaseiq co-change --full
+```
+
+`incomplete-migration` looks for a new helper used at some matching sites while
+older inline forms remain. `twin-drift` looks for same-concept implementations
+that have diverged. `co-change` uses Git history to find files that repeatedly
+change together without a visible dependency edge. Each is evidence for
+inspection, not proof that code must be rewritten.
+
+For compiler-checked dead-code removal:
+
+```bash
+codebaseiq cleanup-plan --verify
+```
+
+Review its batches before applying them. Cleanup is complete only when the
+retired path, unused wiring, and misleading residue are gone and native checks
+still pass.
+
+## Focused graph queries
+
+Use the aggregate `context` command first for ordinary planning. Reach for a
+focused query when one unresolved relationship can change the decision:
+
+```bash
+codebaseiq refs SomeSymbol --full
+codebaseiq trace SomeSymbol
+codebaseiq call-graph SomeSymbol
+codebaseiq value-flow SomeSymbol
+codebaseiq affected SomeSymbol --full
+codebaseiq system src/payments
+codebaseiq surface src/payments
+codebaseiq deps src/payments/service.ts
+codebaseiq rdeps src/payments/service.ts
+```
+
+Do not repeat an unchanged query after context compaction. Re-run when source,
+the index generation, the command input, or the required coverage changed.
+
+## Suppressions
+
+A suppression is a versioned repository record that says one detector finding
+is accepted or is not actionable for a stated reason. Its defining trait is
+that it addresses one finding without weakening unrelated analysis.
+
+```bash
+codebaseiq suppress SQ123 \
+  --check twin-drift \
+  --file src/example.ts \
+  --reason-code intentional-variation \
+  --reason "The two implementations follow different external contracts."
+```
+
+Commit relevant `.codebaseiq/suppressions/*.json` files with the code or policy
+that justifies them. Suppressions are merge-friendly because each finding uses
+its own file.
+
+## Output and coverage
+
+Human output is the default because it keeps hierarchy, whitespace, and source
+line numbers readable. Programmatic consumers can use:
+
+```bash
+codebaseiq context RetryPolicy --json --result-only
+```
+
+Search output separates a complete occurrence ledger from source
+materialization. Every exact matching path and line is listed with its owner;
+the default expands only a representative source subset. Use the emitted
+batched drilldowns for selected owners. `search --full` expands every source
+window and is not needed to establish complete text-match coverage.
+
+Cross-command evidence citations are off by default. With an explicit
+`CODEBASEIQ_SESSION`, a complete source unit, a byte-identical exact subset of a
+prior exact source read, or a graph unit/edge may be replaced by a visible
+receipt from the same index generation. Preview coverage never suppresses an
+exact unit. Changed bytes, changed graph content, a new generation, or
+`--reemit` force full evidence.
+
+If output prints `Continue exactly:`, run the emitted command unchanged until
+transport is complete. Transport completion means every rendered character was
+retrieved; it does not make bounded analysis exhaustive.
+
+Use `--full` only when complete command coverage can change a decision. Always
+read a command's coverage note before claiming that every caller, consumer, or
+finding was considered.
+
+## Configuration
+
+Project policy lives in `.codebaseiq.json`. Common sections configure source
+paths, generated or vendor exclusions, documentation snapshots, architecture
+boundaries, declared coupling, coverage contracts, and watcher behavior.
+
+Validate it with:
+
+```bash
+codebaseiq config-validate
+```
+
+Keep configuration small. Add a rule only when an observed repository fact or
+team policy requires it.
+
+### Reducing background CPU load
+
+Two environment variables shape how much CPU codebaseiq takes from foreground
+work. Both are off by default and change scheduling only, never output.
+
+- `CODEBASEIQ_PROCESS_PRIORITY=low` runs the CLI and everything it spawns
+  (language indexers, health-phase subprocesses, semantic helpers, the watch
+  server) at below-normal OS priority; `idle` yields even further. Work
+  finishes with the same results, it just stops competing with interactive
+  applications.
+- `CODEBASEIQ_MAX_CONCURRENCY=<n>` is a hard ceiling on codebaseiq's adaptive
+  subprocess fan-out (health phases, diff-impact batches). It caps both the
+  adaptive defaults and explicit per-workload values such as
+  `CODEBASEIQ_HEALTH_CONCURRENCY`.
+
+## Command reference
+
+The generated syntax catalog is in
+[`docs/COMMAND_REFERENCE.md`](docs/COMMAND_REFERENCE.md). The one bundled
+`codebaseiq` skill teaches mapping, ordinary planning, architecture checks,
+and focused use of the React, Vue, and general cleanup detectors.
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm test
+npm run build
+```
+
+The React and Vue detector suites are part of the normal test surface and must
+remain passing when the workflow or command surface changes.

package/dist/augment-vue-worker.js

@@ -0,0 +1,2 @@
+import{e as t}from"./chunk-VFY6Y2H6.js";import"./chunk-YUKYB54I.js";import"./chunk-3IER7Q6H.js";import"./chunk-FM5BPL4V.js";import"./chunk-WE5RZHZ7.js";import{writeFileSync as s}from"fs";import{workerData as o}from"worker_threads";var r=o;try{let e=t({projectRoot:r.projectRoot,dbPath:r.dbPath,tsconfig:r.tsconfig,vueFiles:r.vueFiles,tasks:r.tasks});s(r.resultPath,JSON.stringify({version:1,runId:r.runId,workerId:r.workerId,taskIds:r.taskIds,ok:!0,result:e}))}catch(e){s(r.resultPath,JSON.stringify({version:1,runId:r.runId,workerId:r.workerId,taskIds:r.taskIds,ok:!1,error:e instanceof Error?e.message:String(e)}))}
+//# sourceMappingURL=augment-vue-worker.js.map

package/dist/call-graph-evidence-gNsxjCW8.d.ts

@@ -0,0 +1,16 @@
+type CalleeEvidenceSource = 'ast-callsite' | 'semantic-callee' | 'scip-chunk';
+interface CalleeRow {
+    symbol: string;
+    file: string;
+    chunkId: number;
+    source: CalleeEvidenceSource;
+    /** Zero-based source line of the call expression when retained by the evidence source. */
+    callsiteLine?: number;
+}
+interface GraphRowsMapEvidence<T> {
+    rows: Map<number, T[]>;
+    incompleteSymbolIds: Set<number>;
+    unavailableSymbolIds: Set<number>;
+}
+
+export type { CalleeRow as C, GraphRowsMapEvidence as G, CalleeEvidenceSource as a };

package/dist/change-analysis-types-CCtoCHbC.d.ts

@@ -0,0 +1,9 @@
+type DocCitationKind = 'behavioral-claim' | 'configuration-example' | 'guide-reference' | 'intentional-record';
+/** A contiguous changed line span within one file, as parsed from a diff. */
+interface ChangedLineRange {
+    file: string;
+    startLine: number;
+    endLine: number;
+}
+
+export type { ChangedLineRange as C, DocCitationKind as D };

package/dist/chunk-2Q2LW5JW.js

@@ -0,0 +1,14 @@
+import{execFileSync as l,spawnSync as y}from"child_process";import{platform as E}from"os";import{resolve as b}from"path";import{createHash as m}from"crypto";import{existsSync as a,renameSync as u,rmSync as d,writeFileSync as f}from"fs";import{tmpdir as w}from"os";import{join as S}from"path";var c=`'use strict';
+const NativeRegExp = globalThis.RegExp;
+const escapeLoneSeparator = (args) =>
+  typeof args[0] === 'string' && args[0] === '\\\\' ? ['\\\\\\\\', ...args.slice(1)] : args;
+globalThis.RegExp = new Proxy(NativeRegExp, {
+  construct(target, args) {
+    return Reflect.construct(target, escapeLoneSeparator(args));
+  },
+  apply(target, thisArg, args) {
+    return Reflect.apply(target, thisArg, escapeLoneSeparator(args));
+  },
+});
+`,x=/scip-python/i;function p(t,r=process.platform){return r!=="win32"||!x.test(t)?[]:["--require",h()]}function h(t=w()){let r=m("sha256").update(c).digest("hex").slice(0,16),e=S(t,`codebaseiq-indexer-compat-${r}.cjs`);if(a(e))return e;let n=`${e}.${process.pid}.tmp`;f(n,c);try{u(n,e)}catch{if(d(n,{force:!0}),!a(e))throw new Error(`could not materialize indexer compatibility preload at ${e}`)}return e}var g=E()==="win32";function k(t,r=y){try{return r(t,["--version"],{stdio:"ignore",timeout:1e4}).status===0}catch{return!1}}function D(t){let r=g?"where":"which";try{return l(r,[t],{stdio:"pipe",timeout:1e4,killSignal:"SIGKILL"}),!0}catch{return!1}}var R=/\.(?:c|m)?js$/i,I=/\.(?:exe|com)$/i;function $(t,r){return R.test(t)?{binary:process.execPath,args:[...p(t),t,...r]}:{binary:t,args:[...r]}}function A(t,r){return l(t,r,{stdio:["ignore","pipe","ignore"],windowsHide:!0,encoding:"utf8",timeout:1e4,killSignal:"SIGKILL"})}function B(t,r={}){let e=r.isWindows??g,n=r.lookup??A,i;try{i=n(e?"where":"which",[t])}catch{return null}let s=i.split(/\r?\n/).map(o=>o.trim()).filter(Boolean);if(!e){let o=s[0];return o?b(o):null}return s.find(o=>I.test(o))??null}export{k as a,D as b,$ as c,B as d};
+//# sourceMappingURL=chunk-2Q2LW5JW.js.map