Skip to content

Find code by asking what it does. A CLI for coding agents that uses Jev to discover relevant files and source context.

Mark class context structurally instead of by name

taeskim2cd0fbd4214e
diff --git a/packages/core/src/parser-declarations.mjs b/packages/core/src/parser-declarations.mjs
index aa81645..ff9c423 100644
--- a/packages/core/src/parser-declarations.mjs
+++ b/packages/core/src/parser-declarations.mjs
@@ -93,6 +93,7 @@ export function declarations(root, language) {
name: prefix + owner + ".context",
range: header,
ownerHeaders: [...ownedHeaders, header],
+ classContext: true,
});
visit(
body.namedChildren,
diff --git a/packages/core/src/parser-helpers.mjs b/packages/core/src/parser-helpers.mjs
index e7f6f1e..ad38213 100644
--- a/packages/core/src/parser-helpers.mjs
+++ b/packages/core/src/parser-helpers.mjs
@@ -174,6 +174,7 @@ function inspectPython(root) {
startLine: cursor,
endLine: start - 1,
ownerHeaders: own,
+ classContext: true,
});
visit([child], named + ".", own);
cursor = endLine(child) + 1;
@@ -184,6 +185,7 @@ function inspectPython(root) {
startLine: cursor,
endLine: r.endLine,
ownerHeaders: own,
+ classContext: true,
});
} else units.push({ name: named, ...r, ownerHeaders: headers });
}
diff --git a/packages/core/src/retrieve.ts b/packages/core/src/retrieve.ts
index f7f591d..e584398 100644
--- a/packages/core/src/retrieve.ts
+++ b/packages/core/src/retrieve.ts
@@ -645,9 +645,7 @@ export async function retrieve(input: SearchInput, evaluator: Evaluator): Promis
).units;
const classes = [
...new Set(
- units
- .filter((unit) => unit.name.endsWith(".context"))
- .map((unit) => unit.name.split(".")[0]!),
+ units.filter((unit) => unit.classContext).map((unit) => unit.name.split(".")[0]!),
),
];
if (classes.length && Buffer.byteLength(JSON.stringify(classes)) < 4000) {
diff --git a/packages/core/src/selection.ts b/packages/core/src/selection.ts
index d0424e7..451c4c4 100644
--- a/packages/core/src/selection.ts
+++ b/packages/core/src/selection.ts
@@ -131,6 +131,7 @@ export async function selectFile(
sourceByteStart: offsets[start - 1]!,
sourceByteEnd: offsets[end]!,
partial: true,
+ ...(unit.classContext ? { classContext: true as const } : {}),
});
}
return blocks;
@@ -305,7 +306,7 @@ export async function selectFile(
contextSpans.push(span);
if (!partialLine(unit)) selectedCoordinates.push(unit.range);
}
- if (value > 0.25 && !unit.name.endsWith(".context"))
+ if (value > 0.25 && !unit.classContext)
addLead({
name: unit.name,
range: partialLine(unit)
diff --git a/packages/core/src/source.ts b/packages/core/src/source.ts
index 9ddbb7c..98771fa 100644
--- a/packages/core/src/source.ts
+++ b/packages/core/src/source.ts
@@ -12,6 +12,9 @@ export type SourceUnit = {
sourceByteEnd: number;
partial?: boolean;
ownerHeaders?: Range[];
+ /** Structural class, impl or module source between members. The name alone cannot identify
+ * it: a real member named `context` shares the `<Owner>.context` name. */
+ classContext?: true;
};
export type Inspection = {
units: SourceUnit[];
@@ -126,22 +129,21 @@ export async function inspect(
: [],
});
if (Buffer.byteLength(source) > maxParseBytes) return fallback("size");
- let units: { name: string; range: Range; ownerHeaders?: Range[] }[] = [],
+ let units: { name: string; range: Range; ownerHeaders?: Range[]; classContext?: true }[] = [],
comments: Range[] = [],
mode: Inspection["mode"];
let syntaxFallback = false;
if (language === "python") {
// A missing/incompatible packaged parser is a setup failure, never syntax fallback.
- const parsed = await runParser<Array<Range & { name: string; ownerHeaders: Range[] }>>(
- "inspect",
- source,
- options.signal,
- );
+ const parsed = await runParser<
+ Array<Range & { name: string; ownerHeaders: Range[]; classContext?: boolean }>
+ >("inspect", source, options.signal);
if (parsed === null) return fallback("syntax");
- units = parsed.map(({ name, startLine, endLine, ownerHeaders }) => ({
+ units = parsed.map(({ name, startLine, endLine, ownerHeaders, classContext }) => ({
name,
range: { startLine, endLine },
ownerHeaders,
+ ...(classContext === true ? { classContext: true as const } : {}),
}));
comments = pythonComments;
mode = "python";
@@ -170,7 +172,13 @@ export async function inspect(
first = line(node.members[0]!.getStart(file));
const header = first > start ? { startLine: start, endLine: first - 1 } : undefined;
const headers = header ? [...ownerHeaders, header] : ownerHeaders;
- if (header) units.push({ name: name + ".context", range: header, ownerHeaders: headers });
+ if (header)
+ units.push({
+ name: name + ".context",
+ range: header,
+ ownerHeaders: headers,
+ classContext: true,
+ });
for (const member of node.members) add(member, name + ".", headers);
} else
units.push({
@@ -208,7 +216,10 @@ export async function inspect(
options.signal,
);
if (!parsed) return fallback("syntax");
- units = parsed.units;
+ units = parsed.units.map(({ classContext, ...unit }) => ({
+ ...unit,
+ ...(classContext === true ? { classContext: true as const } : {}),
+ }));
comments = parsed.comments;
mode = language;
} else return fallback("unsupported");
@@ -242,6 +253,7 @@ export async function inspect(
text.bytes.length,
text.offsets[unit.range.endLine] ?? text.bytes.length,
);
+ const marker = unit.classContext ? { classContext: true as const } : {};
if (end - start <= maxUnitBytes)
return [
{
@@ -251,11 +263,13 @@ export async function inspect(
ownerHeaders: unit.ownerHeaders,
sourceByteStart: start,
sourceByteEnd: end,
+ ...marker,
},
];
return textUnits(text, unit.range, unit.name, maxUnitBytes, true).map((part) => ({
...part,
ownerHeaders: unit.ownerHeaders,
+ ...marker,
}));
}),
};
diff --git a/packages/core/src/test-body-selection.ts b/packages/core/src/test-body-selection.ts
index 1796f06..acf11b4 100644
--- a/packages/core/src/test-body-selection.ts
+++ b/packages/core/src/test-body-selection.ts
@@ -37,7 +37,7 @@ export async function selectTestBodies(
for (const unit of syntax.units) {
if (
unit.partial ||
- unit.name.endsWith(".context") ||
+ unit.classContext ||
!file.selected.some((r) => r.sourceByteStart === undefined && contains(r, unit.range)) ||
!shown.some((e) => contains(e.range, unit.range))
)
diff --git a/packages/core/test/selection.test.ts b/packages/core/test/selection.test.ts
index b1e5e94..221fdad 100644
--- a/packages/core/test/selection.test.ts
+++ b/packages/core/test/selection.test.ts
@@ -369,3 +369,48 @@ test("a failure or invalidation observed during preparation stops later dispatch
expect(invalidated.file.selected).toEqual([]);
expect(invalidated.file.leads).toEqual([]);
});
+
+test("a real member named context remains a reading lead", async () => {
+ const located = async (path: string, source: string) =>
+ (
+ await selectFile(
+ { path, contentHash: path, source },
+ "render context",
+ 0.9,
+ evaluator(() => 0.9),
+ )
+ ).file.leads.map((lead) => `${lead.name}@${lead.range.startLine}-${lead.range.endLine}`);
+ expect(
+ await located(
+ "template.py",
+ 'class Template:\n """Render with a context."""\n engine = None\n\n def context(self, request):\n return {"request": request}\n\n def render(self, request):\n return self.context(request)\n',
+ ),
+ ).toEqual(["Template.context@5-6", "Template.render@8-9"]);
+ expect(
+ await located(
+ "widget.ts",
+ 'export class Widget {\n static kind = "w";\n context(): Record<string, unknown> {\n return {};\n }\n render() {\n return this.context();\n }\n}\n',
+ ),
+ ).toEqual(["Widget.kind@2-2", "Widget.context@3-5", "Widget.render@6-8"]);
+ expect(
+ await located(
+ "widget.rs",
+ "struct Widget;\nimpl Widget {\n fn context(&self) -> u32 {\n 1\n }\n fn render(&self) -> u32 {\n self.context()\n }\n}\n",
+ ),
+ ).toEqual(["Widget@1-1", "Widget.context@3-5", "Widget.render@6-8"]);
+});
+
+test("oversized class context split into blocks stays out of leads", async () => {
+ const source =
+ "export class Big {\n" +
+ ` // ${"x".repeat(70)}\n`.repeat(400) +
+ " method() {\n return 1;\n }\n}\n";
+ const result = await selectFile(
+ { path: "big.ts", contentHash: "big", source },
+ "q",
+ 0.9,
+ evaluator(() => 0.9),
+ );
+ expect(result.file.selected.length).toBeGreaterThan(0);
+ expect(result.file.leads.map((lead) => lead.name)).toEqual(["Big.method"]);
+});
diff --git a/test/parser/parity.test.ts b/test/parser/parity.test.ts
index a19d8a5..07cbe51 100644
--- a/test/parser/parity.test.ts
+++ b/test/parser/parity.test.ts
@@ -51,11 +51,16 @@ test("Python declaration, preview, neighborhood and inherited-call outputs match
],
},
);
- assert.deepEqual(
- await runParser(helper, input),
- reference(helper, input),
- `${helper}: ${base}`,
- );
+ const actual = await runParser(helper, input);
+ // The frozen helper predates the class-context marker; parity covers boundaries and names.
+ const comparable =
+ helper === "inspect" && Array.isArray(actual)
+ ? actual.map(({ classContext, ...unit }: { classContext?: boolean; name: string }) => {
+ if (classContext) assert.ok(unit.name.endsWith(".context"), unit.name);
+ return unit;
+ })
+ : actual;
+ assert.deepEqual(comparable, reference(helper, input), `${helper}: ${base}`);
}
}
});
diff --git a/test/parser/source.test.ts b/test/parser/source.test.ts
index a4db84b..fdc92e4 100644
--- a/test/parser/source.test.ts
+++ b/test/parser/source.test.ts
@@ -415,3 +415,42 @@ test("Python nested beyond the query depth falls back quickly while wide files p
assert.equal(parsed.mode, "python");
assert.equal(parsed.units[0]?.name, "f");
});
+
+test("class context is marked structurally, not inferred from member names", async () => {
+ const marked = async (path: string, source: string) =>
+ (await inspect({ path, source, contentHash: "fixture" })).units.map(
+ ({ name, range, classContext }) =>
+ `${name}@${range.startLine}-${range.endLine}${classContext ? " [class context]" : ""}`,
+ );
+ assert.deepEqual(
+ await marked(
+ "template.py",
+ 'class Template:\n """Render with a context."""\n engine = None\n\n def context(self, request):\n return {"request": request}\n\n def render(self, request):\n return self.context(request)\n',
+ ),
+ [
+ "Template.context@1-4 [class context]",
+ "Template.context@5-6",
+ "Template.context@7-7 [class context]",
+ "Template.render@8-9",
+ ],
+ );
+ assert.deepEqual(
+ await marked(
+ "widget.ts",
+ 'export class Widget {\n static kind = "w";\n context() {\n return {};\n }\n}\nexport class Inline { context() { return 1; } }\n',
+ ),
+ [
+ "Widget.context@1-1 [class context]",
+ "Widget.kind@2-2",
+ "Widget.context@3-5",
+ "Inline.context@7-7",
+ ],
+ );
+ assert.deepEqual(
+ await marked(
+ "widget.rs",
+ "struct Widget;\nimpl Widget {\n fn context(&self) -> u32 {\n 1\n }\n}\n",
+ ),
+ ["Widget@1-1", "Widget.context@2-2 [class context]", "Widget.context@3-5"],
+ );
+});
diff --git a/test/retrieval.test.ts b/test/retrieval.test.ts
index 4bd9bab..ea98341 100644
--- a/test/retrieval.test.ts
+++ b/test/retrieval.test.ts
@@ -707,3 +707,42 @@ testIfDocker(
}
},
);
+
+for (const [layout, source, expected] of [
+ ["class header", "export class Widget {\n context() { return 1; }\n}\n", 1],
+ ["member named context only", "export class Widget { context() { return 1; } }\n", 0],
+] as const)
+ testIfDocker(`relationship anchoring follows class structure: ${layout}`, async () => {
+ const root = await mkdtemp(join(tmpdir(), "jg-anchor-"));
+ let relationships = 0;
+ try {
+ await mkdir(join(root, "pkg/sub"), { recursive: true });
+ await writeFile(join(root, "widget.ts"), source);
+ await writeFile(
+ join(root, "pkg/sub/child.ts"),
+ "export class Child extends Widget { context() { return 2; } }\n",
+ );
+ await retrieve(
+ { root, query: "widget context", signal: new AbortController().signal },
+ {
+ requests: 0,
+ async evaluate(request) {
+ const state = request.state as {
+ relationAnchor?: unknown;
+ items?: Array<{ kind: string }>;
+ };
+ if (state.relationAnchor) relationships++;
+ return Object.fromEntries(
+ Object.keys(request.questions).map((id, index) => [
+ id,
+ state.items ? (state.items[index]?.kind === "file" ? 0.9 : 0.1) : 0.9,
+ ]),
+ );
+ },
+ },
+ );
+ expect(relationships).toBe(expected);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+ });