@handsupmin/gc-tree 0.7.17 → 0.7.19

package/dist/src/cli.js

@@ -12,9 +12,9 @@ import { DEFAULT_BRANCH, branchDir, resolveHome } from './paths.js';
 import { branchRepoMapPath, branchScopeStatus, detectCurrentRepoId, promptResolveScopeDecision, readBranchRepoMap, resolveBranchForRepo, setRepoScopeForBranch, } from './repo-map.js';
 import { findRelatedDocs, getDocById, resolveContext } from './resolve.js';
 import { scaffoldHostIntegration } from './scaffold.js';
-import { requirePreferredProvider, writeSettings, readSettings } from './settings.js';
+import { appendScaffoldedHost, requirePreferredProvider, writeSettings, readSettings } from './settings.js';
 import { checkoutBranch, initHome, listBranches, readHead, resetBranchContext, statusForBranch, ensureBranchExists, isBranchContextEmpty } from './store.js';
-import { updateBranchContext } from './update.js';
+import { selfUpdate, updateBranchContext } from './update.js';
 import { uninstallGcTree } from './uninstall.js';
 import { verifyOnboarding } from './verify-onboarding.js';
 function readArg(flag) {
@@ -59,6 +59,7 @@ function usage() {
   gctree update-gc [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
   gctree ugc [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
   gctree scaffold --host <codex|claude-code|both> [--target DIR] [--force]
+  gctree update
 
 Internal commands:
   gctree __apply-onboarding --input FILE [--home DIR] [--branch NAME]
@@ -102,13 +103,16 @@ function normalizeProviderMode(value) {
 async function resolvePreferredProvider(home, explicitProvider) {
     return normalizeProvider(explicitProvider) || (await requirePreferredProvider(home));
 }
-async function ensureScaffold({ providerMode, targetDir, force = false, scope = 'local', }) {
+async function ensureScaffold({ providerMode, targetDir, force = false, scope = 'local', home: scaffoldHome, }) {
     const hosts = providerMode === 'both' ? ['claude-code', 'codex'] : [providerMode];
     const combined = { hosts: providerMode, target_dir: scope === 'global' ? '(global)' : (targetDir || process.cwd()), written: [], skipped_existing: [] };
     for (const host of hosts) {
         const result = await scaffoldHostIntegration({ host, targetDir, force, scope });
         combined.written.push(...result.written);
         combined.skipped_existing.push(...result.skipped_existing);
+        if (scaffoldHome && result.written.length > 0) {
+            await appendScaffoldedHost(scaffoldHome, { host, scope, target_dir: scope === 'local' ? (targetDir || process.cwd()) : undefined });
+        }
     }
     return combined;
 }
@@ -181,9 +185,9 @@ async function main() {
                 preferredProvider: provider,
                 preferredLanguage,
             });
-            const globalScaffold = await ensureScaffold({ providerMode, scope: 'global', force: hasFlag('--force') });
+            const globalScaffold = await ensureScaffold({ providerMode, scope: 'global', force: hasFlag('--force'), home });
             const scaffold = explicitTargetDir
-                ? await ensureScaffold({ providerMode, targetDir: explicitTargetDir, scope: 'local', force: hasFlag('--force') })
+                ? await ensureScaffold({ providerMode, targetDir: explicitTargetDir, scope: 'local', force: hasFlag('--force'), home })
                 : null;
             const launch = (await isBranchContextEmpty(home, result.gc_branch))
                 ? await launchGuidedFlow({
@@ -285,7 +289,7 @@ async function main() {
             const settings = await readSettings(home);
             const targetDir = readArg('--target') || process.cwd();
             const scaffold = readArg('--target')
-                ? await ensureScaffold({ providerMode: settings?.provider_mode || provider, targetDir, scope: 'local', force: hasFlag('--force') })
+                ? await ensureScaffold({ providerMode: settings?.provider_mode || provider, targetDir, scope: 'local', force: hasFlag('--force'), home })
                 : null;
             const launch = await launchGuidedFlow({
                 provider,
@@ -482,7 +486,7 @@ async function main() {
             const settings = await readSettings(home);
             const targetDir = readArg('--target') || process.cwd();
             const scaffold = readArg('--target')
-                ? await ensureScaffold({ providerMode: settings?.provider_mode || provider, targetDir, scope: 'local', force: hasFlag('--force') })
+                ? await ensureScaffold({ providerMode: settings?.provider_mode || provider, targetDir, scope: 'local', force: hasFlag('--force'), home })
                 : null;
             const launch = await launchGuidedFlow({
                 provider,
@@ -532,10 +536,15 @@ async function main() {
                 providerMode: host,
                 ...(isGlobal ? { scope: 'global' } : { targetDir: explicitTarget, scope: 'local' }),
                 force: hasFlag('--force'),
+                home,
             });
             console.log(JSON.stringify(result, null, 2));
             return;
         }
+        case 'update': {
+            await selfUpdate(home);
+            return;
+        }
         default:
             usage();
     }

package/dist/src/scaffold.js

@@ -8,7 +8,11 @@ function renderCodexAgentsSnippet() {
         '',
         '- Treat the active gctree branch as a **gc-branch** when you describe it to users.',
         '- gctree init installs SessionStart and UserPromptSubmit hooks that auto-check gc-tree before work.',
-        '- When you encounter an unfamiliar term, acronym, concept, or domain word, run `gctree resolve --query "<term>"` **before** grepping or reading code files. The gc-tree index is the first lookup, not the last resort.',
+        '- When you encounter an unfamiliar term, acronym, concept, or domain word, follow this protocol **before** grepping or reading code files:',
+        '  1. Run `gctree resolve --query "<term>"` — if matched, use the result directly.',
+        '  2. If no match, try broader related queries to check if the concept lives in any doc.',
+        '  3. If the concept exists in a doc but was not indexed → propose adding it as an Index Entry to that doc (so future resolves find it).',
+        '  4. If it does not exist anywhere → decide whether a new doc is needed and propose it to the user.',
         '- When a UserPromptSubmit hook provides `[gc-tree] PRE-TASK CONTEXT`, treat it as mandatory pre-reading before any tool use.',
         '- If the injected summaries contain enough information to answer the question or complete the task, respond directly from them **without calling any tools**. Do not grep, explore, or read code files to confirm what the summaries already cover.',
         '- Only use tools if the summaries are clearly insufficient — meaning the answer cannot be derived from them at all.',
@@ -114,7 +118,11 @@ function renderClaudeSnippet() {
         '',
         '- Treat the active gctree branch as a **gc-branch** in user-facing language.',
         '- gctree init installs SessionStart and UserPromptSubmit hooks that auto-inject gc-tree context before every prompt.',
-        '- When you encounter an unfamiliar term, acronym, concept, or domain word, run `gctree resolve --query "<term>"` **before** grepping or reading code files. The gc-tree index is the first lookup, not the last resort.',
+        '- When you encounter an unfamiliar term, acronym, concept, or domain word, follow this protocol **before** grepping or reading code files:',
+        '  1. Run `gctree resolve --query "<term>"` — if matched, use the result directly.',
+        '  2. If no match, try broader related queries to check if the concept lives in any doc.',
+        '  3. If the concept exists in a doc but was not indexed → propose adding it as an Index Entry to that doc (so future resolves find it).',
+        '  4. If it does not exist anywhere → decide whether a new doc is needed and propose it to the user.',
         '- When a UserPromptSubmit hook provides `[gc-tree] PRE-TASK CONTEXT`, treat it as mandatory pre-reading before any tool use.',
         '- If the injected summaries contain enough information to answer the question or complete the task, respond directly from them **without calling any tools**. Do not grep, explore, or read code files to confirm what the summaries already cover.',
         '- Only use tools if the summaries are clearly insufficient — meaning the answer cannot be derived from them at all.',

package/dist/src/settings.js

@@ -21,6 +21,17 @@ export async function writeSettings({ home, providerMode, preferredProvider, pre
     await writeFile(settingsPath(home), `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
     return settings;
 }
+export async function appendScaffoldedHost(home, record) {
+    const settings = await readSettings(home);
+    if (!settings)
+        return;
+    const existing = settings.scaffolded_hosts || [];
+    const filtered = existing.filter((h) => !(h.host === record.host && h.scope === record.scope && h.target_dir === record.target_dir));
+    filtered.push({ ...record, scaffolded_at: new Date().toISOString() });
+    const updated = { ...settings, scaffolded_hosts: filtered, updated_at: new Date().toISOString() };
+    await mkdir(home, { recursive: true });
+    await writeFile(settingsPath(home), `${JSON.stringify(updated, null, 2)}\n`, 'utf8');
+}
 export async function requirePreferredProvider(home) {
     const settings = await readSettings(home);
     if (!settings?.preferred_provider) {

package/dist/src/update.js

@@ -1,7 +1,8 @@
-import { mkdir, writeFile } from 'node:fs/promises';
+import { execSync } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { renderDocMarkdown, slugify } from './markdown.js';
-import { branchDocsDir, DEFAULT_BRANCH } from './paths.js';
+import { branchDocsDir, DEFAULT_BRANCH, settingsPath } from './paths.js';
 import { ensureBranchExists, updateBranchMeta, writeIndexFromDocs } from './store.js';
 function docRelativePath(doc) {
     if (doc.slug?.includes('/'))
@@ -31,3 +32,35 @@ export async function updateBranchContext({ home, input, branch, }) {
         index_path: index.index_path,
     };
 }
+async function readScaffoldedHosts(home) {
+    try {
+        const raw = await readFile(settingsPath(home), 'utf8');
+        const settings = JSON.parse(raw);
+        return settings.scaffolded_hosts || [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function selfUpdate(home) {
+    const hosts = await readScaffoldedHosts(home);
+    if (hosts.length === 0) {
+        process.stderr.write('No scaffolded providers found in settings. Run `gctree scaffold --host <host>` first.\n');
+    }
+    else {
+        process.stderr.write(`Found ${hosts.length} scaffolded provider(s): ${hosts.map((h) => `${h.host}(${h.scope})`).join(', ')}\n`);
+    }
+    process.stderr.write('\nUpdating gctree to latest...\n');
+    execSync('npm install -g @handsupmin/gc-tree@latest', { stdio: 'inherit' });
+    if (hosts.length > 0) {
+        process.stderr.write('\nRe-scaffolding providers with new version...\n');
+        for (const record of hosts) {
+            const args = ['gctree', 'scaffold', '--host', record.host, '--force'];
+            if (record.scope === 'local' && record.target_dir)
+                args.push('--target', record.target_dir);
+            process.stderr.write(`  ${args.join(' ')}\n`);
+            execSync(args.join(' '), { stdio: 'inherit' });
+        }
+    }
+    process.stderr.write('\ngctree update complete.\n');
+}

package/package.json

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