@handsupmin/gc-tree 0.8.14 → 0.8.16

package/dist/src/cli.js

@@ -86,6 +86,22 @@ function compactMatchCommands(id, home, branch) {
         related: `gctree related --id ${JSON.stringify(id)} ${homeArg} ${branchArg}`,
     };
 }
+function formatResolveText({ status, gcBranch, currentRepo, matches, message, }) {
+    if (status !== 'matched') {
+        return `[gc-tree] ${message}\n`;
+    }
+    const lines = [
+        `[gc-tree] 관련 문서 ${matches.length}개 gc-branch="${gcBranch}" repo="${currentRepo || 'unscoped'}"`,
+    ];
+    for (const match of matches.slice(0, 5)) {
+        const keyword = (match.label || match.title || match.id).trim();
+        const context = (match.summary || match.excerpt || '').trim();
+        const shortContext = context.length > 140 ? `${context.slice(0, 137).trim()}...` : context;
+        lines.push(`[${keyword}] 관련 문서 존재${shortContext ? `: ${shortContext}` : ''}`);
+        lines.push(`[${keyword}] 세부 정보 탐색: gctree show-doc --id "${match.id}" --branch "${gcBranch}"`);
+    }
+    return `${lines.join('\n')}\n`;
+}
 function normalizeProvider(value) {
     if (!value)
         return undefined;
@@ -360,6 +376,7 @@ async function main() {
             const currentRepo = resolved.current_repo;
             let scopeStatus = resolved.scope_status;
             const settings = await readSettings(home);
+            const jsonOutput = hasFlag('--json');
             if (currentRepo && scopeStatus === 'unmapped') {
                 const decision = await promptResolveScopeDecision(gcBranch, currentRepo, settings?.preferred_language || 'English');
                 if (decision === 'always-use') {
@@ -368,19 +385,31 @@ async function main() {
                 }
                 else if (decision === 'ignore') {
                     await setRepoScopeForBranch({ home, branch: gcBranch, repo: currentRepo, mode: 'exclude' });
-                    console.log(JSON.stringify({
+                    const payload = {
+                        status: 'excluded',
                         gc_branch: gcBranch,
                         query,
                         current_repo: currentRepo,
                         source: resolved.source,
                         repo_scope_status: 'excluded',
+                        message: `Repo "${currentRepo}" is excluded from gc-branch "${gcBranch}".`,
                         matches: [],
-                    }, null, 2));
+                    };
+                    if (jsonOutput)
+                        console.log(JSON.stringify(payload, null, 2));
+                    else
+                        stdout.write(formatResolveText({
+                            status: payload.status,
+                            gcBranch,
+                            currentRepo,
+                            matches: [],
+                            message: payload.message,
+                        }));
                     return;
                 }
             }
             if (currentRepo && scopeStatus === 'excluded') {
-                console.log(JSON.stringify({
+                const payload = {
                     status: 'excluded',
                     gc_branch: gcBranch,
                     query,
@@ -389,12 +418,22 @@ async function main() {
                     repo_scope_status: 'excluded',
                     message: `Repo "${currentRepo}" is excluded from gc-branch "${gcBranch}".`,
                     matches: [],
-                }, null, 2));
+                };
+                if (jsonOutput)
+                    console.log(JSON.stringify(payload, null, 2));
+                else
+                    stdout.write(formatResolveText({
+                        status: payload.status,
+                        gcBranch,
+                        currentRepo,
+                        matches: [],
+                        message: payload.message,
+                    }));
                 return;
             }
             const branchStatus = await statusForBranch(home, gcBranch);
             if (branchStatus.doc_count === 0) {
-                console.log(JSON.stringify({
+                const payload = {
                     status: 'empty_branch',
                     gc_branch: gcBranch,
                     query,
@@ -403,25 +442,49 @@ async function main() {
                     repo_scope_status: scopeStatus,
                     message: `gc-branch "${gcBranch}" has no docs yet. Run gctree onboard to add durable context.`,
                     matches: [],
-                }, null, 2));
+                };
+                if (jsonOutput)
+                    console.log(JSON.stringify(payload, null, 2));
+                else
+                    stdout.write(formatResolveText({
+                        status: payload.status,
+                        gcBranch,
+                        currentRepo,
+                        matches: [],
+                        message: payload.message,
+                    }));
                 return;
             }
             const result = await resolveContext({ home, branch: gcBranch, query });
-            console.log(JSON.stringify({
-                status: result.matches.length > 0 ? 'matched' : 'no_match',
+            const status = result.matches.length > 0 ? 'matched' : 'no_match';
+            const message = result.matches.length > 0
+                ? `Found ${result.matches.length} matching docs. Use show-doc/related for progressive disclosure.`
+                : `No matching docs found in gc-branch "${gcBranch}" for this query.`;
+            const payload = {
+                status,
                 gc_branch: result.branch,
                 query: result.query,
                 current_repo: currentRepo,
                 source: resolved.source,
                 repo_scope_status: scopeStatus,
-                message: result.matches.length > 0
-                    ? `Found ${result.matches.length} matching docs. Use show-doc/related for progressive disclosure.`
-                    : `No matching docs found in gc-branch "${gcBranch}" for this query.`,
+                message,
                 matches: result.matches.map((match) => ({
                     ...match,
                     commands: compactMatchCommands(match.id, home, gcBranch),
                 })),
-            }, null, 2));
+            };
+            if (jsonOutput) {
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                stdout.write(formatResolveText({
+                    status,
+                    gcBranch,
+                    currentRepo,
+                    matches: result.matches,
+                    message,
+                }));
+            }
             return;
         }
         case 'show-doc': {

package/dist/src/hook.js

@@ -24,19 +24,24 @@ function recentDuplicate(previousAt, now, windowMs = 5000) {
 function limitMatches(matches, max = 3) {
     return matches.slice(0, max);
 }
+function displayKeyword(match) {
+    return (match.label || match.title || match.id).trim();
+}
 function formatMatches(matches) {
     return limitMatches(matches)
-        .map((match, index) => {
+        .map((match) => {
         const summary = match.summary?.trim() ?? '';
         const excerpt = match.excerpt?.trim() ?? '';
-        // Use summary if it looks actionable (long enough to contain patterns).
-        // Fall back to a trimmed excerpt when summary is a short description-only sentence.
-        const context = summary.length >= 60 ? summary : (excerpt.slice(0, 300) || summary);
-        return context
-            ? `${index + 1}. ${match.title} [${match.id}]\n   > ${context}`
-            : `${index + 1}. ${match.title} [${match.id}]`;
+        const context = summary || excerpt;
+        const shortContext = context.length > 180 ? `${context.slice(0, 177).trim()}...` : context;
+        const showDoc = `gctree show-doc --id "${match.id}"`;
+        return [
+            `[${displayKeyword(match)}]`,
+            shortContext,
+            `details: ${showDoc}`,
+        ].join('\n');
     })
-        .join('\n');
+        .join('\n\n');
 }
 function buildSessionStartContext({ gcBranch, currentRepo, repoScopeStatus, }) {
     return `[gc-tree] active gc-branch="${gcBranch}" repo="${currentRepo || 'unscoped'}" scope=${repoScopeStatus}.`;
@@ -53,8 +58,10 @@ function buildNoMatchContext({ gcBranch, currentRepo, cached, }) {
 function buildMatchContext({ gcBranch, currentRepo, repoScopeStatus, matches, }) {
     const lines = [
         `[gc-tree] USE FIRST: ${Math.min(matches.length, 3)} docs gc-branch="${gcBranch}" repo="${currentRepo || 'unscoped'}" scope=${repoScopeStatus}.`,
+        '',
         formatMatches(matches),
-        `Rule: summaries above are mandatory context — read them now. Only run \`gctree resolve --id <id>\` if a summary is insufficient for the task.`,
+        '',
+        `Rule: 위 문서를 먼저 근거로 삼고, 부족하면 details 명령으로 세부 정보를 확인.`,
     ];
     if (repoScopeStatus === 'unmapped' && currentRepo) {
         lines.push(`Note: repo "${currentRepo}" is unmapped. If it belongs here, offer to run: gctree set-repo-scope --branch ${gcBranch} --include`);

package/dist/src/markdown.js

@@ -295,14 +295,31 @@ export function extractTitle(markdown) {
     return match?.[1]?.trim() || '';
 }
 export function extractExcerpt(markdown, query) {
-    const content = String(markdown || '').replace(/\s+/g, ' ').trim();
+    const content = String(markdown || '')
+        .replace(/^#+\s+/gm, '')
+        .replace(/\s+/g, ' ')
+        .trim();
     if (!content)
         return '';
-    const normalized = query.toLowerCase();
-    const index = content.toLowerCase().indexOf(normalized);
-    if (index === -1)
-        return content.slice(0, 140);
-    const start = Math.max(0, index - 40);
-    const end = Math.min(content.length, index + normalized.length + 80);
-    return content.slice(start, end).trim();
+    const tokens = String(query || '')
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .flatMap((t) => t.split(/(?<=[a-z0-9])(?=[^\x00-\x7f])|(?<=[^\x00-\x7f])(?=[a-z0-9])/))
+        .filter((t) => t.length >= 2);
+    if (tokens.length === 0)
+        return content.slice(0, 180);
+    const chunks = content
+        .split(/(?<=[.!?。！？])\s+|\s+-\s+|(?=\b[A-Z][A-Za-z ]+:)/)
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
+    const scored = chunks
+        .map((chunk, index) => ({
+        chunk,
+        index,
+        score: tokens.reduce((sum, token) => sum + (chunk.toLowerCase().includes(token) ? 1 : 0), 0),
+    }))
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index);
+    const best = scored[0]?.chunk || content;
+    return best.length > 220 ? `${best.slice(0, 217).trim()}...` : best;
 }

package/dist/src/resolve.js

@@ -27,8 +27,7 @@ function makeTokenRegex(token) {
         ? new RegExp(`\\b${token}\\b`)
         : new RegExp(`(?<!\\p{L})${token}(?!\\p{L})`, 'u');
 }
-function scoreText(text, query) {
-    const tokens = tokenize(query);
+function countTokenMatches(text, tokens) {
     if (tokens.length === 0)
         return 0;
     const haystack = String(text || '').toLowerCase();
@@ -42,13 +41,58 @@ function scoreText(text, query) {
         }
     }, 0);
 }
+function scoreText(text, query) {
+    return countTokenMatches(text, tokenize(query));
+}
+function exactPhraseScore(text, query) {
+    const phrase = String(query || '').trim().toLowerCase();
+    if (phrase.length < 4)
+        return 0;
+    return String(text || '').toLowerCase().includes(phrase) ? 6 : 0;
+}
+function scoreDoc(entry, query) {
+    const tokens = tokenize(query);
+    if (tokens.length === 0)
+        return 0;
+    const labelScore = countTokenMatches(entry.label, tokens) * 10;
+    const titleScore = countTokenMatches(entry.title, tokens) * 7;
+    const summaryScore = countTokenMatches(entry.summary, tokens) * 5;
+    const categoryScore = countTokenMatches(entry.category, tokens) * 2;
+    const pathScore = countTokenMatches(entry.path, tokens) * 2;
+    const contentScore = countTokenMatches(entry.content, tokens);
+    const phraseScore = exactPhraseScore(entry.label, query) +
+        exactPhraseScore(entry.title, query) +
+        exactPhraseScore(entry.summary, query) +
+        exactPhraseScore(entry.content, query);
+    return labelScore + titleScore + summaryScore + categoryScore + pathScore + contentScore + phraseScore;
+}
+function minimumUsefulScore(query) {
+    return tokenize(query).length <= 1 ? 1 : 2;
+}
+function labelQueryPosition(label, query) {
+    const normalizedQuery = String(query || '').toLowerCase();
+    const positions = tokenize(label)
+        .map((token) => normalizedQuery.indexOf(token))
+        .filter((index) => index >= 0);
+    return positions.length > 0 ? Math.min(...positions) : Number.MAX_SAFE_INTEGER;
+}
+function betterMatch(candidate, previous, query) {
+    return (!previous ||
+        candidate.score > previous.score ||
+        (candidate.score === previous.score &&
+            labelQueryPosition(candidate.label, query) < labelQueryPosition(previous.label, query)));
+}
 async function readBranchDocs(home, branch) {
     const indexRaw = await readFile(branchIndexPath(home, branch), 'utf8');
     const entries = parseIndexEntries(indexRaw);
-    const uniqueEntries = [...new Map(entries.map((entry) => [entry.path, entry])).values()];
-    return Promise.all(uniqueEntries.map(async (entry) => {
+    const contentCache = new Map();
+    return Promise.all(entries.map(async (entry) => {
         const fullPath = join(branchDir(home, branch), entry.path);
-        const raw = await readFile(fullPath, 'utf8');
+        let raw = contentCache.get(fullPath);
+        if (!raw) {
+            raw = await readFile(fullPath, 'utf8');
+            contentCache.set(fullPath, raw);
+        }
         return {
             id: entry.id || docIdFromPath(entry.path),
             title: extractTitle(raw) || entry.title,
@@ -62,16 +106,13 @@ async function readBranchDocs(home, branch) {
 }
 export async function resolveContext({ home, branch, query, }) {
     const entries = await readBranchDocs(home, branch);
-    const matches = [];
+    const matchesById = new Map();
+    const minScore = minimumUsefulScore(query);
     for (const entry of entries) {
-        const combined = `${entry.title}\n${entry.summary}\n${entry.content}`;
-        // Title matches count double (higher signal density)
-        const titleScore = scoreText(entry.title, query);
-        const bodyScore = scoreText(`${entry.summary}\n${entry.content}`, query);
-        const score = titleScore * 2 + bodyScore;
-        if (score <= 0)
+        const score = scoreDoc(entry, query);
+        if (score < minScore)
             continue;
-        matches.push({
+        const match = {
             id: entry.id,
             label: entry.label,
             category: entry.category,
@@ -80,12 +121,15 @@ export async function resolveContext({ home, branch, query, }) {
             score,
             summary: entry.summary,
             excerpt: extractExcerpt(entry.content, query),
-        });
+        };
+        if (betterMatch(match, matchesById.get(match.id), query)) {
+            matchesById.set(match.id, match);
+        }
     }
     return {
         branch,
         query,
-        matches: matches.sort((a, b) => b.score - a.score || a.title.localeCompare(b.title)),
+        matches: [...matchesById.values()].sort((a, b) => b.score - a.score || a.title.localeCompare(b.title)),
     };
 }
 export async function getDocById({ home, branch, id, }) {
@@ -102,26 +146,26 @@ export async function findRelatedDocs({ home, branch, id, limit = 5, }) {
         return { status: 'doc_not_found', selected: null, matches: [] };
     }
     const query = `${selected.title}\n${selected.summary}`;
-    const matches = docs
-        .filter((doc) => doc.id !== selected.id)
-        .map((doc) => {
-        const titleScore = scoreText(doc.title, query);
-        const bodyScore = scoreText(`${doc.summary}\n${doc.content}`, query);
-        const score = titleScore * 2 + bodyScore;
-        return score > 0
-            ? {
-                id: doc.id,
-                label: doc.label,
-                category: doc.category,
-                title: doc.title,
-                path: doc.path,
-                score,
-                summary: doc.summary,
-                excerpt: extractExcerpt(doc.content, query),
-            }
-            : null;
-    })
-        .filter((match) => Boolean(match))
+    const matchesById = new Map();
+    for (const doc of docs.filter((doc) => doc.id !== selected.id)) {
+        const score = scoreDoc(doc, query);
+        if (score <= 0)
+            continue;
+        const match = {
+            id: doc.id,
+            label: doc.label,
+            category: doc.category,
+            title: doc.title,
+            path: doc.path,
+            score,
+            summary: doc.summary,
+            excerpt: extractExcerpt(doc.content, query),
+        };
+        if (betterMatch(match, matchesById.get(match.id), query)) {
+            matchesById.set(match.id, match);
+        }
+    }
+    const matches = [...matchesById.values()]
         .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
         .slice(0, limit);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@handsupmin/gc-tree",
-  "version": "0.8.14",
+  "version": "0.8.16",
   "description": "Global Context Tree, a lightweight branch-aware global context orchestrator for AI coding tools",
   "type": "module",
   "private": false,