@kentwynn/kgraph 0.2.14 → 0.2.15

package/dist/cli/commands/pack.js

@@ -26,7 +26,7 @@ export function registerPackCommand(program) {
             readMaps(workspace),
         ]);
         const response = await queryContext(workspace, config, maps, task);
-        const pack = buildContextPack(response, budget);
+        const pack = buildContextPack(response, budget, workspace.rootPath);
         if (options.json) {
             console.log(JSON.stringify(pack, null, 2));
             return;

package/dist/context/context-pack.d.ts

@@ -1,3 +1,3 @@
 import type { ContextResponse } from '../types/cognition.js';
 import type { ContextPack } from '../types/knowledge.js';
-export declare function buildContextPack(response: ContextResponse, budget: number): ContextPack;
+export declare function buildContextPack(response: ContextResponse, budget: number, rootPath?: string): ContextPack;

package/dist/context/context-pack.js

@@ -1,5 +1,8 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
 import { estimateTokens } from '../session/token-estimator.js';
-export function buildContextPack(response, budget) {
+import { tokenize } from './ranking.js';
+export function buildContextPack(response, budget, rootPath) {
     const candidates = [
         ...response.relevantFiles.map((ranked) => ({
             kind: 'file',
@@ -9,6 +12,7 @@ export function buildContextPack(response, budget) {
             reasons: ranked.reasons,
             data: ranked.item,
         })),
+        ...buildFileRangeCandidates(response, budget, rootPath),
         ...response.relevantSymbols.map((ranked) => ({
             kind: 'symbol',
             id: ranked.item.id,
@@ -76,15 +80,17 @@ function comparePackCandidates(left, right) {
 function packPriority(item) {
     let score = 0;
     if (item.kind === 'atom')
-        score += 40;
+        score += 1000;
     if (item.kind === 'git-change')
-        score += 35;
+        score += 900;
+    if (item.kind === 'file-range')
+        score += 800;
     if (item.kind === 'symbol')
-        score += 25;
+        score += 300;
     if (item.kind === 'file')
-        score += 15;
+        score += 200;
     if (item.kind === 'relationship')
-        score += 5;
+        score += 100;
     if (item.reasons.some((reason) => reason.includes('matched atom')))
         score += 30;
     if (item.reasons.some((reason) => reason.includes('current git change')))
@@ -96,3 +102,104 @@ function packPriority(item) {
     score -= Math.floor(item.tokenEstimate / 2000);
     return score;
 }
+const GENERIC_RANGE_TOKENS = new Set([
+    'app',
+    'code',
+    'component',
+    'file',
+    'page',
+    'repo',
+    'work',
+]);
+function buildFileRangeCandidates(response, budget, rootPath) {
+    if (!rootPath)
+        return [];
+    const queryTokens = tokenize(response.query).filter((token) => token.length >= 3 && !GENERIC_RANGE_TOKENS.has(token));
+    if (queryTokens.length === 0)
+        return [];
+    const maxRangeTokens = Math.max(250, Math.min(1200, Math.floor(budget / 3)));
+    const candidates = [];
+    for (const rankedFile of response.relevantFiles.slice(0, 8)) {
+        const file = rankedFile.item;
+        const fileTokens = file.tokenEstimate ?? 0;
+        if (fileTokens <= Math.max(1000, Math.floor(budget / 2)))
+            continue;
+        const fullPath = path.join(rootPath, file.path);
+        if (!existsSync(fullPath))
+            continue;
+        let content = '';
+        try {
+            content = readFileSync(fullPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const ranges = selectQueryRanges(content, queryTokens, maxRangeTokens, file.path);
+        for (const range of ranges) {
+            const lines = content.split(/\r?\n/).slice(range.start - 1, range.end);
+            const excerpt = lines.join('\n');
+            candidates.push({
+                kind: 'file-range',
+                id: `${file.path}:${range.start}-${range.end}`,
+                title: `${file.path}:${range.start}-${range.end}`,
+                tokenEstimate: estimateTokens(excerpt, file.path),
+                reasons: [
+                    ...rankedFile.reasons,
+                    `range selected from oversized file`,
+                    `line text matched ${range.tokens.map((token) => `"${token}"`).join(', ')}`,
+                ],
+                data: {
+                    path: file.path,
+                    startLine: range.start,
+                    endLine: range.end,
+                    excerpt,
+                },
+            });
+        }
+    }
+    return candidates;
+}
+function selectQueryRanges(content, queryTokens, maxRangeTokens, filePath) {
+    const lines = content.split(/\r?\n/);
+    const hits = [];
+    for (const [index, line] of lines.entries()) {
+        const lower = line.toLowerCase();
+        const matched = queryTokens.filter((token) => lower.includes(token));
+        if (matched.length === 0)
+            continue;
+        hits.push({
+            start: Math.max(1, index + 1 - 8),
+            end: Math.min(lines.length, index + 1 + 8),
+            tokens: matched,
+        });
+    }
+    const ranges = mergeRanges(hits);
+    return ranges
+        .sort((left, right) => right.tokens.length - left.tokens.length)
+        .slice(0, 3)
+        .map((range) => trimRangeToBudget(range, lines, maxRangeTokens, filePath));
+}
+function mergeRanges(ranges) {
+    const merged = [];
+    for (const range of ranges.sort((left, right) => left.start - right.start)) {
+        const current = merged.at(-1);
+        if (!current || range.start > current.end + 3) {
+            merged.push({ ...range, tokens: [...new Set(range.tokens)] });
+            continue;
+        }
+        current.end = Math.max(current.end, range.end);
+        current.tokens = [...new Set([...current.tokens, ...range.tokens])];
+    }
+    return merged;
+}
+function trimRangeToBudget(range, lines, maxRangeTokens, filePath) {
+    let start = range.start;
+    let end = Math.min(range.end, start + 79);
+    while (end > start + 4) {
+        const excerpt = lines.slice(start - 1, end).join('\n');
+        if (estimateTokens(excerpt, filePath) <= maxRangeTokens)
+            break;
+        end -= 5;
+    }
+    return { ...range, start, end };
+}

package/dist/types/knowledge.d.ts

@@ -75,7 +75,7 @@ export interface KnowledgeValidationIssue {
     atomId?: string;
 }
 export interface ContextPackItem {
-    kind: 'file' | 'symbol' | 'atom' | 'relationship' | 'git-change';
+    kind: 'file' | 'file-range' | 'symbol' | 'atom' | 'relationship' | 'git-change';
     id: string;
     title: string;
     tokenEstimate: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {