@mrclrchtr/supi-lsp 10.0.0 → 11.0.1

package/node_modules/@mrclrchtr/supi-code-runtime/src/file-associations.ts

@@ -0,0 +1,190 @@
+import * as path from "node:path";
+import picomatch from "picomatch";
+
+/** Language selected for a C-family source file. */
+export type CFamilyLanguage = "c" | "cpp";
+
+/** One ordered, project-relative language rule for an existing C-family file. */
+export interface CFamilyFileAssociationRule {
+  readonly pattern: string;
+  readonly language: CFamilyLanguage;
+}
+
+/** C-family suffixes that already have Tree-sitter and LSP support. */
+export const C_FAMILY_EXTENSIONS = Object.freeze([
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cc",
+  ".cxx",
+  ".hxx",
+  ".c++",
+  ".h++",
+] as const);
+
+export type CFamilyExtension = (typeof C_FAMILY_EXTENSIONS)[number];
+
+const DEFAULT_C_FAMILY_LANGUAGES: Readonly<Record<CFamilyExtension, CFamilyLanguage>> =
+  Object.freeze({
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".hpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hxx": "cpp",
+    ".c++": "cpp",
+    ".h++": "cpp",
+  });
+
+/** Immutable C-family language selection for one workspace. */
+export interface CFamilyFileAssociationResolver {
+  /** Absolute root used to make project-relative paths. */
+  readonly workspaceRoot: string;
+  /** Validated ordered rules captured when the workspace host starts. */
+  readonly rules: readonly CFamilyFileAssociationRule[];
+  /** Select the configured language or the existing suffix default. */
+  languageForFile(filePath: string): CFamilyLanguage | undefined;
+}
+
+/** Return the current default language for one supported C-family suffix. */
+export function defaultCFamilyLanguage(extension: string): CFamilyLanguage | undefined {
+  return DEFAULT_C_FAMILY_LANGUAGES[extension.toLowerCase() as CFamilyExtension];
+}
+
+/**
+ * Validate and compile ordered C-family file associations for one workspace.
+ * Patterns are case-sensitive globs over POSIX-style, workspace-relative paths.
+ * Supported patterns use `*`, `?`, `**`, character classes, and brace alternatives.
+ * The first matching rule wins. Rules never expand the eligible suffix set.
+ *
+ * @throws If the rule list, a rule, a language, or a pattern is invalid.
+ */
+export function createCFamilyFileAssociationResolver(
+  workspaceRoot: string,
+  input: unknown = [],
+): CFamilyFileAssociationResolver {
+  const rules = validateRules(input);
+  const matchers = rules.map((rule, index) => ({
+    language: rule.language,
+    matches: compilePattern(rule.pattern, `code-intelligence.fileAssociations[${index}]`),
+  }));
+  const root = path.resolve(workspaceRoot);
+  return Object.freeze({
+    workspaceRoot: root,
+    rules,
+    languageForFile(filePath: string): CFamilyLanguage | undefined {
+      const extension = normalizeExtension(filePath);
+      const fallback = defaultCFamilyLanguage(extension);
+      if (!fallback) return undefined;
+
+      const absolutePath = path.resolve(root, filePath);
+      const relativePath = toPosixPath(path.relative(root, absolutePath));
+      if (
+        relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        path.posix.isAbsolute(relativePath)
+      ) {
+        return fallback;
+      }
+      for (const rule of matchers) {
+        if (rule.matches(relativePath)) return rule.language;
+      }
+      return fallback;
+    },
+  });
+}
+
+function validateRules(input: unknown): readonly CFamilyFileAssociationRule[] {
+  if (!Array.isArray(input)) {
+    throw new Error('Invalid "code-intelligence.fileAssociations": expected an ordered array.');
+  }
+  if (input.length > 64) {
+    throw new Error('Invalid "code-intelligence.fileAssociations": use no more than 64 rules.');
+  }
+  const rules: CFamilyFileAssociationRule[] = [];
+  const seenPatterns = new Set<string>();
+  for (const [index, value] of input.entries()) {
+    const key = `code-intelligence.fileAssociations[${index}]`;
+    if (!isRecord(value) || !hasExactKeys(value, ["pattern", "language"])) {
+      throw new Error(`${key} must contain only "pattern" and "language" fields.`);
+    }
+    if (typeof value.pattern !== "string") {
+      throw new Error(`${key}.pattern must be a string.`);
+    }
+    if (value.language !== "c" && value.language !== "cpp") {
+      throw new Error(`${key}.language must be "c" or "cpp".`);
+    }
+    if (seenPatterns.has(value.pattern)) {
+      throw new Error(`${key}.pattern duplicates an earlier rule.`);
+    }
+    seenPatterns.add(value.pattern);
+    rules.push(Object.freeze({ pattern: value.pattern, language: value.language }));
+  }
+  return Object.freeze(rules);
+}
+
+function compilePattern(pattern: string, key: string): (file: string) => boolean {
+  if (
+    pattern.length === 0 ||
+    pattern.length > 512 ||
+    pattern !== pattern.trim() ||
+    pattern.includes("\\") ||
+    hasControlCharacter(pattern) ||
+    pattern.startsWith("/") ||
+    /^[A-Za-z]:/.test(pattern) ||
+    pattern.startsWith("!")
+  ) {
+    throw new Error(`${key}.pattern must be a safe workspace-relative glob using "/" separators.`);
+  }
+  const segments = pattern.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error(`${key}.pattern contains an unsafe or unsupported path pattern.`);
+  }
+  try {
+    return picomatch(pattern, {
+      nocase: false,
+      windows: false,
+      dot: true,
+      strictBrackets: true,
+      nonegate: true,
+      noextglob: true,
+      maxLength: 512,
+    });
+  } catch (error) {
+    throw new Error(`${key}.pattern is not a valid glob: ${errorMessage(error)}`, { cause: error });
+  }
+}
+
+function hasControlCharacter(value: string): boolean {
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
+function normalizeExtension(filePath: string): string {
+  return path.posix.extname(toPosixPath(filePath)).toLowerCase();
+}
+
+function toPosixPath(value: string): string {
+  return value.replaceAll("\\", "/");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  const allowed = new Set(keys);
+  return (
+    keys.every((key) => Object.hasOwn(value, key)) &&
+    Object.keys(value).every((key) => allowed.has(key))
+  );
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts

@@ -80,6 +80,14 @@ export interface DocumentCodeSymbol extends CodeSymbol {
  */
 export type CodeResult<T> =
   | { kind: "success"; data: T }
+  | {
+      kind: "partial";
+      data: T;
+      file: string;
+      reason: string;
+      /** Syntax error and missing-node ranges in 0-based UTF-16 coordinates. */
+      errorRanges: SourceRange[];
+    }
   | { kind: "unsupported-language"; file: string; message: string }
   | { kind: "file-access-error"; file: string; message: string }
   | { kind: "validation-error"; message: string }
@@ -93,7 +101,10 @@ export type ConfidenceMode = "semantic" | "structural" | "heuristic" | "unavaila
 
 export interface OutlineData {
   name: string;
+  /** Common structural search category. */
   kind: string;
+  /** Source-language declaration kind, separate from common search category. */
+  nativeKind?: string;
   /** Exact 1-based start of the declaration name token, when known. */
   nameAnchor?: SymbolAnchor;
   /** Exclusive 1-based end of a verified literal name span, when known. */
@@ -156,6 +167,12 @@ export interface FileEdit {
 /** A document-state precondition established when semantic edits are normalized. */
 export type DocumentEditPrecondition =
   | { file: string; kind: "open-document-version"; version: number }
+  | {
+      file: string;
+      kind: "open-document-content";
+      version: number;
+      fingerprint: string;
+    }
   | { file: string; kind: "disk-content" };
 
 /**
@@ -257,5 +274,10 @@ export interface CalleesData {
 /** A single call-site match with name and start line. */
 export interface CallSite {
   name: string;
+  /** 1-based UTF-16 start position of the written callee expression. */
   startLine: number;
+  startCharacter: number;
+  /** Exclusive 1-based UTF-16 end position of the captured source expression. */
+  endLine: number;
+  endCharacter: number;
 }

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "10.0.0",
+  "version": "11.0.1",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/ignore/README.md

@@ -173,6 +173,29 @@ ig.ignores(path.join('./abc'))  // path.join('./abc') -> 'abc'
 
 In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
 
+A `.` or `..` component anywhere else in a `Pathname` is outside the
+convention as well, though no error is thrown for it: the check reads how the
+path starts, so that it costs nothing on a hot path. `path.relative()` never
+produces such a component, and one that carries it is not matched the way
+`git` matches it — `git` drops the component from the path first, `ignore`
+matches the path as it was given.
+
+```js
+// path.relative('/', '/a/./b')  -> 'a/b'
+
+// Right
+ignore().add('a/b').ignores('a/b')       // true
+
+// Outside the convention: git matches 'a/b' here and so says true
+ignore().add('a/b').ignores('a/./b')     // false
+
+// Outside the convention: git matches 'a' here and so says false
+ignore().add('a/.').ignores('a/.')       // true
+```
+
+A rule that matches an ancestor still agrees, since the component makes no
+difference to it: `add('a').ignores('a/./b')` is `true` either way.
+
 Suppose the dir structure is:
 
 ```
@@ -265,7 +288,8 @@ Returns `TestResult`
 // Since 5.0.0
 interface TestResult {
   ignored: boolean
-  // true if the `pathname` is finally unignored by some negative pattern
+  // true if a negative pattern matched the `pathname` itself, and no parent
+  //   directory of it is ignored -- see "When both are false" below
   unignored: boolean
   // The `IgnoreRule` which ignores the pathname
   rule?: IgnoreRule
@@ -283,8 +307,39 @@ interface IgnoreRule {
 ```
 
 - `{ignored: true, unignored: false}`: the `pathname` is ignored
-- `{ignored: false, unignored: true}`: the `pathname` is unignored
-- `{ignored: false, unignored: false}`: the `pathname` is never matched by any ignore rules.
+- `{ignored: false, unignored: true}`: a negative pattern matched the `pathname` itself
+- `{ignored: false, unignored: false}`: no rule matched the `pathname` itself, and no parent directory of it is ignored
+
+### When both are `false`
+
+`{ignored: false, unignored: false}` covers two different situations:
+
+- no rule matched the `pathname`, nor any of its parent directories, or
+- no rule matched the `pathname` itself, but one of its parent directories is unignored by a negative pattern: the `pathname` is unignored **indirectly**.
+
+`unignored` stays `false` in the second case because only `ignored` passes down from a parent directory. A `pathname` whose parent directory is ignored is ignored as well — git never re-includes a file whose parent directory is excluded — but one whose parent directory is unignored is decided on its own, by the rules that match the `pathname` itself.
+
+```js
+const ig2 = ignore().add([
+  'foo*',
+  '!foobar'
+])
+
+// The directory `foobar/` is unignored directly, by `!foobar`
+ig2.test('foobar/')     // {ignored: false, unignored: true}
+
+// No rule matches `foobar/x.js` itself. It is not ignored only because its
+//   parent directory `foobar/` is not, so it is unignored indirectly
+ig2.test('foobar/x.js') // {ignored: false, unignored: false}
+```
+
+To tell the two situations apart, test the parent directories of the `pathname`, each with a trailing slash: the `pathname` is unignored indirectly if any of them is `unignored`.
+
+```js
+['foobar/'].some(dir => ig2.test(dir).unignored) // true
+```
+
+`unignored` is meant for packages that implement their own caching mechanism upon `node-ignore`. To simply tell whether a `pathname` is ignored, use `.ignores()` or check `TestResult::ignored`.
 
 ## .checkIgnore(target: string): TestResult
 
@@ -294,7 +349,7 @@ Debugs gitignore / exclude files, which is equivalent to `git check-ignore -v`.
 
 - **target** `string` the target to test.
 
-Returns `TestResult`
+Returns `TestResult`, the same shape `.test()` returns, so `{ignored: false, unignored: false}` carries the [same two meanings](#when-both-are-false) here.
 
 ```js
 ig.add({
@@ -305,10 +360,10 @@ ig.add({
 const {
   ignored,
   rule
-} = checkIgnore('foo/')
+} = ig.checkIgnore('foo/')
 
 if (ignored) {
-  console.log(`.gitignore:${result}:${rule.mark}:${rule.pattern} foo/`)
+  console.log(`.gitignore:${rule.mark}:${rule.pattern} foo/`)
 }
 
 // .gitignore:60:foo/* foo/

package/node_modules/ignore/index.d.ts

@@ -1,27 +1,61 @@
-type Pathname = string
-
-interface IgnoreRule {
-  pattern: string
-  mark?: string
-  negative: boolean
-}
-
-interface TestResult {
-  ignored: boolean
-  unignored: boolean
-  rule?: IgnoreRule
-}
-
-interface PatternParams {
-  pattern: string
-  mark?: string
-}
-
 /**
  * Creates new ignore manager.
  */
 declare function ignore(options?: ignore.Options): ignore.Ignore
 declare namespace ignore {
+  /**
+   * A path relative to the directory the rules belong to, as
+   *   `path.relative()` returns it.
+   */
+  type Pathname = string
+
+  interface PatternParams {
+    pattern: string
+    /**
+     * Carried through to `IgnoreRule.mark`, for packages that build upon
+     *   `ignore`.
+     */
+    mark?: string
+  }
+
+  interface IgnoreRule {
+    /**
+     * The original pattern.
+     */
+    pattern: string
+    /**
+     * Carried through from `PatternParams.mark`.
+     */
+    mark?: string
+    /**
+     * Whether the pattern is a negative one, such as `!foo`.
+     */
+    negative: boolean
+  }
+
+  interface TestResult {
+    /**
+     * Whether the pathname is ignored, by a rule or because a parent
+     *   directory of it is.
+     */
+    ignored: boolean
+    /**
+     * True if a negative pattern matched the pathname itself, and no parent
+     *   directory of it is ignored.
+     *
+     * Only `ignored` passes down from a parent directory, so a pathname that
+     *   is not ignored only because a parent directory was unignored keeps
+     *   this false, as does one no rule applies to at all. To tell those two
+     *   apart, test the parent directories, each with a trailing slash.
+     */
+    unignored: boolean
+    /**
+     * The rule that ignores the pathname. Present exactly when `ignored` is
+     *   true.
+     */
+    rule?: IgnoreRule
+  }
+
   interface Ignore {
     /**
      * Adds one or several rules to the current manager.
@@ -54,7 +88,8 @@ declare namespace ignore {
     ignores(pathname: Pathname): boolean
 
     /**
-     * Returns whether pathname should be ignored or unignored
+     * Tests the pathname against the rules. `ignored` and `unignored` can
+     *   both be false: see `TestResult.unignored` for the two cases.
      * @param  {string} pathname a path to check
      * @returns TestResult
      */