@handsupmin/gc-tree 0.7.0 → 0.7.2

package/dist/src/cli.js

@@ -139,6 +139,11 @@ async function launchGuidedFlow({ provider, providerMode, preferredLanguage, tar
         return plan;
     return maybeLaunchProvider(plan);
 }
+function printJsonUnlessLaunched(payload, launch) {
+    if (launch?.launched)
+        return;
+    console.log(JSON.stringify(payload, null, 2));
+}
 async function main() {
     if (hasFlag('--version') || hasFlag('-v')) {
         stdout.write(`${await readPackageVersion()}\n`);
@@ -189,7 +194,7 @@ async function main() {
                     noLaunch: hasFlag('--no-launch'),
                 })
                 : null;
-            console.log(JSON.stringify({
+            printJsonUnlessLaunched({
                 ...result,
                 provider_mode: settings.provider_mode,
                 preferred_provider: settings.preferred_provider,
@@ -197,7 +202,7 @@ async function main() {
                 global_scaffold: globalScaffold,
                 scaffold,
                 launch,
-            }, null, 2));
+            }, launch);
             return;
         }
         case 'checkout': {
@@ -289,7 +294,7 @@ async function main() {
                 command: 'gc-onboard',
                 noLaunch: hasFlag('--no-launch'),
             });
-            console.log(JSON.stringify({ mode: 'guided_onboarding', gc_branch: gcBranch, preferred_provider: provider, scaffold, launch }, null, 2));
+            printJsonUnlessLaunched({ mode: 'guided_onboarding', gc_branch: gcBranch, preferred_provider: provider, scaffold, launch }, launch);
             return;
         }
         case 'verify-onboarding': {
@@ -486,7 +491,7 @@ async function main() {
                 command: 'gc-update-global-context',
                 noLaunch: hasFlag('--no-launch'),
             });
-            console.log(JSON.stringify({ mode: 'guided_update', gc_branch: gcBranch, preferred_provider: provider, scaffold, launch }, null, 2));
+            printJsonUnlessLaunched({ mode: 'guided_update', gc_branch: gcBranch, preferred_provider: provider, scaffold, launch }, launch);
             return;
         }
         case '__apply-update': {

package/dist/src/markdown.js

@@ -7,6 +7,63 @@ export function slugify(value) {
         .replace(/^-|-$/g, '');
     return normalized || 'doc';
 }
+function parseDocReference(value) {
+    const trimmed = String(value || '').trim().replace(/^\.?\//, '');
+    if (!trimmed)
+        return null;
+    const normalized = trimmed.replace(/\\/g, '/');
+    const docsMatch = normalized.match(/^docs\/([^/]+)\/([^/]+?)(?:\.md)?$/i);
+    if (docsMatch) {
+        const category = normalizeCategory(docsMatch[1]);
+        const slug = slugify(docsMatch[2]);
+        if (slug === 'index')
+            return null;
+        return { category, slug, label: docsMatch[2].replace(/\.md$/i, '').trim() };
+    }
+    const directMatch = normalized.match(/^(role|repos|domain|workflows|conventions|infra|verification)\/([^/]+?)(?:\.md)?$/i);
+    if (directMatch) {
+        const category = normalizeCategory(directMatch[1]);
+        const slug = slugify(directMatch[2]);
+        if (slug === 'index')
+            return null;
+        return { category, slug, label: directMatch[2].replace(/\.md$/i, '').trim() };
+    }
+    return null;
+}
+function parseTitlePlacement(value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return null;
+    if (/^index$/i.test(trimmed))
+        return { category: 'index', slug: 'index', label: 'Index' };
+    const match = trimmed.match(/^(role|repo|repos|repository|repositories|domain|workflow|workflows|convention|conventions|infra|verification)\s*:\s*(.+)$/i);
+    if (!match)
+        return null;
+    const rawCategory = match[1].toLowerCase();
+    const categoryMap = {
+        role: 'role',
+        repo: 'repos',
+        repos: 'repos',
+        repository: 'repos',
+        repositories: 'repos',
+        domain: 'domain',
+        workflow: 'workflows',
+        workflows: 'workflows',
+        convention: 'conventions',
+        conventions: 'conventions',
+        infra: 'infra',
+        verification: 'verification',
+    };
+    const label = match[2].trim();
+    const category = categoryMap[rawCategory];
+    if (!category || !label)
+        return null;
+    return {
+        category,
+        slug: slugify(label),
+        label,
+    };
+}
 export function ensureSummary(summary) {
     const trimmed = String(summary || '').trim();
     if (!trimmed) {
@@ -17,6 +74,10 @@ export function ensureSummary(summary) {
 export function renderDocMarkdown(doc) {
     const summary = ensureSummary(doc.summary);
     const body = String(doc.body || '').trim();
+    const normalizedIndexEntries = [...new Set([
+            ...(doc.indexLabel?.trim() ? [doc.indexLabel.trim()] : []),
+            ...(doc.indexEntries || []).map((entry) => String(entry || '').trim()).filter(Boolean),
+        ])];
     return [
         `# ${doc.title.trim()}`,
         '',
@@ -27,8 +88,8 @@ export function renderDocMarkdown(doc) {
         ...(doc.tags && doc.tags.length > 0
             ? ['## Tags', '', ...doc.tags.map((tag) => `- ${tag}`), '']
             : []),
-        ...(doc.indexEntries && doc.indexEntries.length > 0
-            ? ['## Index Entries', '', ...doc.indexEntries.map((entry) => `- ${entry}`), '']
+        ...(normalizedIndexEntries.length > 0
+            ? ['## Index Entries', '', ...normalizedIndexEntries.map((entry) => `- ${entry}`), '']
             : []),
         '## Details',
         '',
@@ -158,6 +219,60 @@ export function extractIndexEntries(markdown) {
         .map((line) => line.slice(2).trim())
         .filter(Boolean);
 }
+export function normalizeIndexEntry(value, fallback) {
+    const reference = parseDocReference(value);
+    if (reference) {
+        return {
+            category: reference.category,
+            label: reference.label,
+        };
+    }
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return null;
+    if (/^docs\/index\.md$/i.test(trimmed) || /^index\.md$/i.test(trimmed))
+        return null;
+    const titlePlacement = parseTitlePlacement(trimmed);
+    if (titlePlacement) {
+        if (titlePlacement.category === 'index')
+            return null;
+        return {
+            category: titlePlacement.category,
+            label: titlePlacement.label,
+        };
+    }
+    return {
+        category: fallback.category,
+        label: trimmed,
+    };
+}
+export function inferDocPlacement(input) {
+    for (const candidate of [input.slug, input.indexLabel]) {
+        const reference = parseDocReference(candidate || '');
+        if (reference) {
+            return { category: reference.category, slug: reference.slug, label: reference.label, isIndexDoc: false };
+        }
+    }
+    const titlePlacement = parseTitlePlacement(input.title);
+    const explicitLabel = String(input.indexLabel || '').trim();
+    const preferredLabel = explicitLabel && !parseDocReference(explicitLabel) ? explicitLabel : input.title.trim();
+    if (titlePlacement) {
+        return {
+            category: titlePlacement.category === 'index' ? null : titlePlacement.category,
+            slug: titlePlacement.slug,
+            label: explicitLabel && !parseDocReference(explicitLabel) ? explicitLabel : titlePlacement.label,
+            isIndexDoc: titlePlacement.category === 'index',
+        };
+    }
+    const explicitCategory = input.category ? slugify(input.category) : null;
+    const slug = slugify(input.slug || input.indexLabel || input.title);
+    return {
+        category: explicitCategory,
+        slug,
+        label: preferredLabel,
+        isIndexDoc: slug === 'index' && explicitCategory === null,
+    };
+}
 export function extractSummary(markdown) {
     const match = String(markdown || '').match(/## Summary\s+([\s\S]*?)(?:\n## |$)/);
     return match?.[1]?.trim() || '';

package/dist/src/onboard.js

@@ -1,13 +1,13 @@
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { renderDocMarkdown, slugify } from './markdown.js';
+import { inferDocPlacement, renderDocMarkdown } from './markdown.js';
 import { branchDocsDir, DEFAULT_BRANCH } from './paths.js';
 import { ensureBranchExists, updateBranchMeta, writeIndexFromDocs } from './store.js';
 function docRelativePath(doc) {
     if (doc.slug?.includes('/'))
         return `${doc.slug.replace(/\.md$/i, '')}.md`;
-    const fileBase = slugify(doc.slug || doc.indexLabel || doc.title);
-    const category = doc.category ? slugify(doc.category) : '';
+    const { category, slug } = inferDocPlacement(doc);
+    const fileBase = slug;
     return category ? `${category}/${fileBase}.md` : `${fileBase}.md`;
 }
 export async function onboardBranch({ home, input, branch, }) {
@@ -17,6 +17,9 @@ export async function onboardBranch({ home, input, branch, }) {
     await mkdir(branchDocsDir(home, targetBranch), { recursive: true });
     const written = [];
     for (const doc of input.docs) {
+        const inferred = inferDocPlacement(doc);
+        if (inferred.isIndexDoc)
+            continue;
         const fullPath = join(branchDocsDir(home, targetBranch), docRelativePath(doc));
         await mkdir(dirname(fullPath), { recursive: true });
         await writeFile(fullPath, renderDocMarkdown(doc), 'utf8');

package/dist/src/store.js

@@ -2,7 +2,7 @@ import { cp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { branchDir, branchDocsDir, branchIndexPath, branchMetaPath, branchesRoot, DEFAULT_BRANCH, headPath, } from './paths.js';
-import { extractIndexEntries, renderIndexMarkdown } from './markdown.js';
+import { extractIndexEntries, inferDocPlacement, normalizeIndexEntry, renderIndexMarkdown } from './markdown.js';
 async function listDocRelativePaths(dir, prefix = '') {
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
     const files = [];
@@ -109,18 +109,24 @@ export async function writeIndexFromDocs(home, branch) {
     const docsDir = branchDocsDir(home, branch);
     await mkdir(docsDir, { recursive: true });
     const files = await listDocRelativePaths(docsDir);
-    const docs = await Promise.all(files.map(async (file) => {
+    const docs = await Promise.all(files.filter((file) => !/(^|\/)index\.md$/i.test(file)).map(async (file) => {
         const raw = await readFile(join(docsDir, file), 'utf8');
         const title = raw.match(/^#\s+(.+)$/m)?.[1]?.trim() || file.replace(/\.md$/i, '').replace(/-/g, ' ');
         const parts = file.replace(/\.md$/i, '').split('/').filter(Boolean);
-        const category = parts.length > 1 ? parts[0] : 'general';
-        const label = parts.length > 1 ? parts[parts.length - 1] : title;
-        const indexEntries = extractIndexEntries(raw);
-        const entryLabels = indexEntries.length > 0 ? indexEntries : [label];
-        return entryLabels.map((entryLabel) => ({
+        const fallbackCategory = parts.length > 1 ? parts[0] : 'general';
+        const fallbackLabel = parts.length > 1 ? parts[parts.length - 1] : title;
+        const inferred = inferDocPlacement({ title });
+        const docCategory = inferred.category || fallbackCategory;
+        const docLabel = inferred.label || fallbackLabel;
+        const indexEntries = extractIndexEntries(raw)
+            .map((entry) => normalizeIndexEntry(entry, { category: docCategory, label: docLabel }))
+            .filter((entry) => Boolean(entry));
+        const entryLabels = indexEntries.length > 0 ? indexEntries : [{ category: docCategory, label: docLabel }];
+        const uniqueEntries = [...new Map(entryLabels.map((entry) => [`${entry.category}::${entry.label}`, entry])).values()];
+        return uniqueEntries.map((entry) => ({
             title,
-            label: entryLabel,
-            category,
+            label: entry.label,
+            category: entry.category,
             path: `docs/${file}`,
         }));
     }));

package/package.json

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