opencode-swarm 7.146.4 → 7.147.0

package/dist/lang/symbol-visibility.d.ts

@@ -34,6 +34,19 @@ export interface SymbolVisibilityContext {
     pythonAllNames?: Set<string> | null;
     /** For Python methods: true if the enclosing class is exported (in __all__ or public naming convention) */
     pythonParentClassExported?: boolean;
+    /**
+     * Tree-sitter node type of the nearest enclosing type container
+     * (`class_declaration`, `interface_declaration`, `enum_declaration`,
+     * `record_declaration`, `struct_declaration`, `object_declaration`), or
+     * `undefined` when the declaration has no enclosing type container.
+     *
+     * Only populated for the JVM/.NET grammars (java/kotlin/csharp), where the
+     * *kind* of container decides the implicit visibility of a member that
+     * carries no explicit modifier (an interface member is implicitly public in
+     * both Java and C#, a C# class member is implicitly private, a Java class
+     * member is implicitly package-private).
+     */
+    parentContainerType?: string;
 }
 export declare function collectCommonJsExports(source: string): Map<string, CommonJsExportInfo>;
 export declare function collectPythonAllNames(source: string): Set<string> | null;

package/dist/tools/repo-graph/builder.d.ts

@@ -258,6 +258,25 @@ export declare function scanFileAsync(filePath: string, absoluteRoot: string, ma
  * @returns Complete RepoGraph with nodes and edges
  * @throws Error if workspace validation fails
  */
+/**
+ * Restore the documented `targetKind` invariant: a `'node'` target is a file
+ * that actually became a graph node.
+ *
+ * Import resolution and the workspace walker apply different filters. The
+ * walker prunes `SKIP_DIRECTORIES` (`node_modules`, `dist`, `vendor`, ...) and
+ * unfollowed symlinks; `resolveModuleSpecifier` consults neither, so a real
+ * file inside a skipped directory resolves happily and produced an edge marked
+ * `targetKind: 'node'` pointing at a node that does not exist. Measured on both
+ * the dotted JVM/.NET path (`import node_modules.com.example.Foo;`) and the
+ * pre-existing relative path (`import '../node_modules/pkg/index'`).
+ *
+ * The edge is a real dependency, so it is kept rather than dropped — it is
+ * reclassified to `'asset'`, which already means "a real file that never
+ * becomes a node" and is correctly excluded from in-degree ranking, importer
+ * and dependent queries, and node-existence checks during incremental
+ * validation. Returns the number of edges reclassified.
+ */
+export declare function reconcileEdgeTargetKinds(graph: RepoGraph): number;
 export declare function buildWorkspaceGraph(workspaceRoot: string, options?: BuildWorkspaceGraphOptions): RepoGraph;
 /**
  * Async, event-loop-safe variant of `buildWorkspaceGraph`. The traversal

package/dist/tools/repo-graph/ontology.d.ts

@@ -15,4 +15,27 @@ export interface ExtractFileOntologyInput {
      */
     hasManifest?: (relDir: string) => boolean;
 }
+/**
+ * Blank the CONTENTS of multi-line string literals, preserving newlines and
+ * length so line-anchored matching still lines up.
+ *
+ * `stripComments` removes comments but keeps string literals verbatim, so a
+ * line-initial `package` / `namespace` token inside a C# verbatim string
+ * (`@"…"`), a C# raw string, or a Java/Kotlin text block (`"""…"""`) matched the
+ * anchored regexes below and won the boundary — the real declaration lost,
+ * because `String.match` takes the first hit. That is legal, compilable source
+ * (a `@"…"` block holding SQL or config is ordinary C#), not a crafted spoof.
+ *
+ * Single-line string literals are not masked: their literal TEXT cannot contain
+ * a raw newline, so no interior line can be line-initial. The one exception is a
+ * C# interpolated string, which may span lines inside an interpolation hole —
+ * but a hole contains code, not literal text, so leaving it unmasked is correct.
+ * Only the multi-line forms are masked, which keeps the change narrow.
+ */
+/**
+ * @internal Exported only so the scanner's structural invariants (termination,
+ * length preservation, line-count preservation) can be fuzzed directly. Not
+ * re-exported from the package index; call `extractFileOntology` instead.
+ */
+export declare function maskMultilineStringLiterals(text: string, language: string): string;
 export declare function extractFileOntology(input: ExtractFileOntologyInput): FileOntology;

package/dist/tools/repo-graph/types.d.ts

@@ -17,8 +17,10 @@ export declare const REPO_GRAPH_FILENAME = "repo-graph.json";
  * self-gates via {@link isSchemaVersionAtLeast} rather than relying on the
  * loader (which only checks that a version string is present, not its value).
  *
- * 1.2.0 adds per-node `exportRanges` (1-based inclusive line spans for each
- * exported symbol) and the top-level `symbolEdges` array (direct symbol-to-
+ * 1.2.0 adds per-node `exportRanges` (1-based inclusive line spans keyed by
+ * symbol name — exported symbols for every grammar, plus non-exported member
+ * defs for java/kotlin/csharp; see the field docs) and the top-level
+ * `symbolEdges` array (direct symbol-to-
  * symbol reference edges). Both fields are optional, so 1.0.0 and 1.1.0 graphs
  * still load without corruption. New queries may use these fields to provide
  * more precise context-packing and symbol-level navigation.
@@ -122,11 +124,22 @@ export interface GraphNode {
      */
     exportLines?: Record<string, number>;
     /**
-     * 1-based inclusive line span for each exported symbol, keyed by symbol
-     * name. Present on graphs built at schema >= 1.2.0; absent on older
-     * graphs. Used for precise context-packing around a symbol.
+     * 1-based inclusive line span per symbol, keyed by symbol name. Present on
+     * graphs built at schema >= 1.2.0; absent on older graphs. Used for precise
+     * context-packing around a symbol.
      * Each span value uses `startLine` / `endLine` to match the codebase
      * convention (see `ContextPackSpan` and `FileSymbolFacts`).
+     *
+     * SCOPE (issue #1529): exported symbols for every grammar, PLUS
+     * non-exported member defs for java/kotlin/csharp. A JVM/.NET member is
+     * deliberately never a file-level export, so without that widening
+     * `context_pack` could return no span at all for a Java method.
+     * `exports` and `exportLines` stay exported-only in every language.
+     *
+     * Duplicate names resolve so this map cannot disagree with `exportLines`:
+     * an exported def outranks a non-exported one; two exported defs take the
+     * last (as `exportLines` does); two non-exported defs take the first, and
+     * never appear in `exportLines` at all.
      */
     exportRanges?: Record<string, {
         startLine: number;
@@ -172,7 +185,22 @@ export interface GraphEdge {
     /**
      * Whether the resolved target is a graph node or an asset. `'node'` targets
      * are scannable source files that become graph nodes; `'asset'` targets are
-     * real files (JSON/CSS/etc.) that never become nodes (schema >= 1.3.0).
+     * real files that never become nodes (schema >= 1.3.0).
+     *
+     * `'asset'` covers TWO cases, and the second is easy to miss:
+     * 1. a non-source file (JSON/CSS/etc.), which was never scannable; and
+     * 2. a file that IS scannable but the walker never indexed — it sits under a
+     *    `SKIP_DIRECTORIES` entry (`node_modules`, `dist`, `vendor`, …) or behind
+     *    an unfollowed symlink. Import resolution does not consult those rules,
+     *    so it can resolve a real `.ts`/`.java` file the graph has no node for.
+     *    Such edges are demoted to `'asset'` at graph assembly (see
+     *    `reconcileEdgeTargetKinds`) so that `'node'` always means "a node exists
+     *    for this target". The demotion is language-agnostic: it applies to any
+     *    source file the walker skipped, not only to JVM/.NET ones.
+     *
+     * Consequence for consumers: `targetKind: 'asset'` no longer implies "not
+     * source code". Use `isScannableSourcePath(edge.target)` if that is what you
+     * actually need to know.
      * Absent on older graphs — callers fall back to `isScannableSourcePath` on
      * the target path. Asset edges only require their source node to exist
      * during incremental validation, and are excluded from in-degree ranking /

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.146.4",
+	"version": "7.147.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",