@handsupmin/gc-tree 0.1.1

package/dist/src/paths.js

@@ -0,0 +1,28 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const DEFAULT_BRANCH = 'main';
+export const INDEX_WARNING_CHARS = 2000;
+export function resolveHome(explicitHome) {
+    return explicitHome || process.env.GCTREE_HOME || join(homedir(), '.gctree');
+}
+export function headPath(home) {
+    return join(home, 'HEAD');
+}
+export function settingsPath(home) {
+    return join(home, 'settings.json');
+}
+export function branchesRoot(home) {
+    return join(home, 'branches');
+}
+export function branchDir(home, branch) {
+    return join(branchesRoot(home), branch);
+}
+export function branchMetaPath(home, branch) {
+    return join(branchDir(home, branch), 'branch.json');
+}
+export function branchIndexPath(home, branch) {
+    return join(branchDir(home, branch), 'index.md');
+}
+export function branchDocsDir(home, branch) {
+    return join(branchDir(home, branch), 'docs');
+}

package/dist/src/proposals.js

@@ -0,0 +1,73 @@
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { renderDocMarkdown, slugify } from './markdown.js';
+import { branchDir, branchDocsDir, branchProposalsDir, DEFAULT_BRANCH } from './paths.js';
+import { ensureBranchExists, updateBranchMeta, writeIndexFromDocs } from './store.js';
+export async function proposeUpdate({ home, input, branch, }) {
+    const targetBranch = branch || input.branch || DEFAULT_BRANCH;
+    await ensureBranchExists(home, targetBranch);
+    await mkdir(branchProposalsDir(home, targetBranch), { recursive: true });
+    const now = new Date().toISOString();
+    const id = `${now.replace(/[:.]/g, '-')}-${slugify(input.title)}`;
+    const proposal = {
+        version: 1,
+        id,
+        status: 'proposed',
+        branch: targetBranch,
+        title: input.title.trim(),
+        summary: input.summary.trim(),
+        created_at: now,
+        changes: input.docs.map((doc) => ({
+            path: `docs/${slugify(doc.slug || doc.title)}.md`,
+            title: doc.title.trim(),
+            summary: doc.summary.trim(),
+            body: doc.body.trim(),
+            ...(doc.tags?.length ? { tags: doc.tags } : {}),
+        })),
+    };
+    const proposalPath = join(branchProposalsDir(home, targetBranch), `${id}.json`);
+    await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
+    return { proposal_path: proposalPath, proposal };
+}
+export async function applyProposal({ home, proposalPath, }) {
+    const raw = await readFile(proposalPath, 'utf8');
+    const proposal = JSON.parse(raw);
+    await ensureBranchExists(home, proposal.branch);
+    await mkdir(branchDocsDir(home, proposal.branch), { recursive: true });
+    const updatedDocs = [];
+    for (const change of proposal.changes) {
+        const fullPath = join(branchDir(home, proposal.branch), change.path);
+        await writeFile(fullPath, renderDocMarkdown({
+            title: change.title,
+            summary: change.summary,
+            body: change.body,
+            tags: change.tags,
+        }), 'utf8');
+        updatedDocs.push(fullPath);
+    }
+    proposal.status = 'applied';
+    proposal.applied_at = new Date().toISOString();
+    await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
+    await writeIndexFromDocs(home, proposal.branch);
+    await updateBranchMeta(home, proposal.branch, {
+        summary: proposal.summary || (await readBranchSummary(home, proposal.branch)),
+    });
+    return {
+        branch: proposal.branch,
+        updated_docs: updatedDocs,
+        proposal_path: proposalPath,
+    };
+}
+async function readBranchSummary(home, branch) {
+    const branchJson = await readFile(join(branchDir(home, branch), 'branch.json'), 'utf8');
+    return JSON.parse(branchJson).summary || '';
+}
+export async function listProposals(home, branch) {
+    return (await readdir(branchProposalsDir(home, branch)).catch(() => []))
+        .filter((file) => file.endsWith('.json'))
+        .sort()
+        .map((file) => join(branchProposalsDir(home, branch), file));
+}
+export function proposalBasename(path) {
+    return basename(path);
+}

package/dist/src/provider.js

@@ -0,0 +1,121 @@
+import { spawn } from "node:child_process";
+import { stderr, stdin } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { onboardingCompletionLines, onboardingProtocolLines, } from "./onboarding-protocol.js";
+export const LANGUAGE_SELECTION_PROMPT = "Choose language:\n1. English (default)\n2. Korean\n3. Other language\n> ";
+export function visibleProviderCommand(provider, command) {
+    const prefix = provider === "codex" ? "$" : "/";
+    return `${prefix}${command}`;
+}
+export async function promptProviderSelection() {
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        const answer = (await rl.question("Choose your LLM CLI provider:\n1. Claude Code\n2. Codex\n3. Both\n> ")).trim();
+        if (answer === "2")
+            return "codex";
+        if (answer === "3")
+            return "both";
+        return "claude-code";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptLaunchProviderSelection() {
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        const answer = (await rl.question("Both providers are enabled. Which one should start onboarding now?\n1. Claude Code\n2. Codex\n> ")).trim();
+        return answer === "2" ? "codex" : "claude-code";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptLanguageSelection() {
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        const parsed = parseLanguageSelectionInput((await rl.question(LANGUAGE_SELECTION_PROMPT)).trim());
+        if (parsed.language)
+            return parsed.language;
+        if (parsed.needsFollowUp) {
+            const typed = (await rl.question("Type your language: ")).trim();
+            return typed || "English";
+        }
+        return "English";
+    }
+    finally {
+        rl.close();
+    }
+}
+export function parseLanguageSelectionInput(answer) {
+    const normalized = answer.trim();
+    if (!normalized)
+        return { language: "English", needsFollowUp: false };
+    if (/^1(?:[\s.)].*)?$/i.test(normalized) || /^english$/i.test(normalized)) {
+        return { language: "English", needsFollowUp: false };
+    }
+    if (/^2(?:[\s.)].*)?$/i.test(normalized) || /^korean$/i.test(normalized)) {
+        return { language: "Korean", needsFollowUp: false };
+    }
+    const customMatch = normalized.match(/^3(?:[\s.)\:,-]+(.+))?$/i);
+    if (customMatch) {
+        const inlineLanguage = customMatch[1]?.trim();
+        return inlineLanguage
+            ? { language: inlineLanguage, needsFollowUp: false }
+            : { language: null, needsFollowUp: true };
+    }
+    return { language: normalized, needsFollowUp: false };
+}
+export function buildProviderLaunchPlan({ provider, providerMode, preferredLanguage, targetDir, gcBranch, command, }) {
+    const providerCommand = visibleProviderCommand(provider, command);
+    const binary = provider === "codex" ? "codex" : "claude";
+    const promptLines = [
+        providerCommand,
+        "",
+        `IMPORTANT LANGUAGE RULE: Use ${preferredLanguage} for every message in this workflow.`,
+        `Do not switch to English or another language unless the user explicitly asks you to.`,
+        `At the start, explicitly say that the active gc-branch is "${gcBranch}" and that the required workflow language is "${preferredLanguage}".`,
+    ];
+    if (command === "gc-onboard") {
+        promptLines.push("IMPORTANT ONBOARDING RULES:");
+        promptLines.push(...onboardingProtocolLines().map((line) => `- ${line}`));
+        promptLines.push(...onboardingCompletionLines().map((line) => `- ${line}`));
+    }
+    const prompt = promptLines.join("\n");
+    return {
+        provider,
+        provider_mode: providerMode,
+        preferred_language: preferredLanguage,
+        binary,
+        args: [prompt],
+        target_dir: targetDir,
+        gc_branch: gcBranch,
+        provider_command: providerCommand,
+        launched: false,
+    };
+}
+export async function maybeLaunchProvider(plan) {
+    if (process.env.GCTREE_DISABLE_PROVIDER_LAUNCH === "1" ||
+        !stdin.isTTY ||
+        !process.stdout.isTTY) {
+        return plan;
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(plan.binary, plan.args, {
+            cwd: plan.target_dir,
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code && code !== 0) {
+                reject(new Error(`${plan.binary} exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+    });
+    return {
+        ...plan,
+        launched: true,
+    };
+}

package/dist/src/repo-map.js

@@ -0,0 +1,149 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stderr } from 'node:process';
+export function branchRepoMapPath(home) {
+    return join(home, 'branch-repo-map.json');
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
+}
+function normalizeRule(rule) {
+    return {
+        ...(rule?.include?.length ? { include: unique(rule.include) } : {}),
+        ...(rule?.exclude?.length ? { exclude: unique(rule.exclude) } : {}),
+    };
+}
+export async function readBranchRepoMap(home) {
+    try {
+        const raw = await readFile(branchRepoMapPath(home), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Object.fromEntries(Object.entries(parsed).map(([branch, rule]) => [branch, normalizeRule(rule)]));
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeBranchRepoMap(home, mapping) {
+    const normalized = Object.fromEntries(Object.entries(mapping).map(([branch, rule]) => [branch, normalizeRule(rule)]));
+    await writeFile(branchRepoMapPath(home), `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+    return normalized;
+}
+export async function setRepoScopeForBranch({ home, branch, repo, mode, }) {
+    const mapping = await readBranchRepoMap(home);
+    const current = normalizeRule(mapping[branch]);
+    const include = new Set(current.include || []);
+    const exclude = new Set(current.exclude || []);
+    if (mode === 'include') {
+        include.add(repo);
+        exclude.delete(repo);
+    }
+    else {
+        exclude.add(repo);
+        include.delete(repo);
+    }
+    mapping[branch] = normalizeRule({
+        include: [...include],
+        exclude: [...exclude],
+    });
+    return writeBranchRepoMap(home, mapping);
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectRepoRoot(startDir = process.cwd()) {
+    let current = resolve(startDir);
+    while (true) {
+        if (await pathExists(join(current, '.git')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export async function detectCurrentRepoId(startDir = process.cwd()) {
+    const root = await detectRepoRoot(startDir);
+    return root ? basename(root) : null;
+}
+export function branchScopeStatus(mapping, branch, repo) {
+    if (!repo)
+        return 'unscoped';
+    const rule = normalizeRule(mapping[branch]);
+    if (rule.exclude?.includes(repo))
+        return 'excluded';
+    if (rule.include?.includes(repo))
+        return 'included';
+    if ((rule.include?.length || 0) > 0 || (rule.exclude?.length || 0) > 0)
+        return 'unmapped';
+    return 'unscoped';
+}
+export async function resolveBranchForRepo({ home, head, explicitBranch, cwd = process.cwd(), }) {
+    const currentRepo = await detectCurrentRepoId(cwd);
+    const mapping = await readBranchRepoMap(home);
+    if (explicitBranch) {
+        return {
+            gc_branch: explicitBranch,
+            current_repo: currentRepo,
+            source: 'explicit',
+            scope_status: branchScopeStatus(mapping, explicitBranch, currentRepo),
+        };
+    }
+    if (currentRepo) {
+        const includedBranches = Object.entries(mapping)
+            .filter(([, rule]) => !rule.exclude?.includes(currentRepo) && rule.include?.includes(currentRepo))
+            .map(([branch]) => branch)
+            .sort();
+        if (includedBranches.length === 1) {
+            const chosen = includedBranches[0];
+            return {
+                gc_branch: chosen,
+                current_repo: currentRepo,
+                source: 'repo-map',
+                scope_status: 'included',
+            };
+        }
+        if (includedBranches.length > 1) {
+            const chosen = includedBranches.includes(head) ? head : includedBranches[0];
+            return {
+                gc_branch: chosen,
+                current_repo: currentRepo,
+                source: 'repo-map',
+                scope_status: 'included',
+            };
+        }
+    }
+    return {
+        gc_branch: head,
+        current_repo: currentRepo,
+        source: 'head',
+        scope_status: branchScopeStatus(mapping, head, currentRepo),
+    };
+}
+export async function promptResolveScopeDecision(branch, repo, preferredLanguage = 'English') {
+    if (!stdin.isTTY && process.env.GCTREE_ALLOW_STDIN_PROMPT !== '1') {
+        throw new Error(`current repo \"${repo}\" is not mapped to gc-branch \"${branch}\". Run interactively to choose whether to continue, include this repo, or ignore this gc-branch here.`);
+    }
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        const isKorean = preferredLanguage.trim().toLowerCase() === 'korean';
+        const answer = (await rl.question(isKorean
+            ? `현재 레포 \"${repo}\"는 gc-branch \"${branch}\"에 아직 매핑되어 있지 않습니다.\n1. 이번만 진행\n2. 앞으로 이 레포에서도 이 gc-branch 사용\n3. 이 레포에서는 이 gc-branch 무시\n> `
+            : `Repo \"${repo}\" is not mapped to gc-branch \"${branch}\".\n1. Continue once\n2. Always use this gc-branch for this repo\n3. Ignore this gc-branch for this repo\n> `)).trim();
+        if (answer === '2')
+            return 'always-use';
+        if (answer === '3')
+            return 'ignore';
+        return 'continue-once';
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/src/resolve.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { extractExcerpt, extractSummary, parseIndexEntries } from './markdown.js';
+import { branchDir, branchIndexPath } from './paths.js';
+function scoreText(text, query) {
+    const tokens = String(query || '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length >= 2);
+    const haystack = String(text || '').toLowerCase();
+    return tokens.reduce((sum, token) => sum + (haystack.includes(token) ? 1 : 0), 0);
+}
+export async function resolveContext({ home, branch, query, }) {
+    const indexRaw = await readFile(branchIndexPath(home, branch), 'utf8');
+    const entries = parseIndexEntries(indexRaw);
+    const matches = [];
+    for (const entry of entries) {
+        const fullPath = join(branchDir(home, branch), entry.path);
+        const raw = await readFile(fullPath, 'utf8');
+        const summary = extractSummary(raw);
+        const combined = `${entry.title}\n${summary}\n${raw}`;
+        const score = scoreText(combined, query);
+        if (score <= 0)
+            continue;
+        matches.push({
+            title: entry.title,
+            path: entry.path,
+            score,
+            summary,
+            excerpt: extractExcerpt(raw, query),
+        });
+    }
+    return {
+        branch,
+        query,
+        matches: matches.sort((a, b) => b.score - a.score || a.title.localeCompare(b.title)),
+    };
+}

package/dist/src/scaffold.js

@@ -0,0 +1,199 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { onboardingCompletionLines, onboardingProtocolLines } from './onboarding-protocol.js';
+function renderCodexAgentsSnippet() {
+    return [
+        '# gctree Codex integration snippet',
+        '',
+        '- Treat the active gctree branch as a **gc-branch** when you describe it to users.',
+        '- Before planning or implementation, run `gctree status` to confirm the active gc-branch if it is unclear.',
+        '- Use `gctree resolve --query "<task>"` when reusable global context may matter.',
+        '- Use `$gc-onboard` only for an empty gc-branch.',
+        '- Use `$gc-update-global-context` when durable context in the active gc-branch should change.',
+        '',
+    ].join('\n');
+}
+function renderCodexBootstrapPrompt() {
+    return [
+        '# gctree Bootstrap',
+        '',
+        '- Keep the active gc-branch explicit whenever global context matters.',
+        '- Resolve reusable global context before planning or implementation when it may change the answer.',
+        '- Read summaries first and only open full docs when needed.',
+        '- Treat gctree docs as explicit source-of-truth markdown, not hidden memory.',
+        '',
+    ].join('\n');
+}
+function renderCodexResolveSkill() {
+    return [
+        '---',
+        'description: Resolve reusable global context from the active gc-branch.',
+        'argument_hint: "<query>"',
+        '---',
+        '',
+        'Treat everything after this command as the query.',
+        '',
+        '1. Run `gctree status` if the active gc-branch is unclear.',
+        '2. Explicitly mention which gc-branch is active before using the result.',
+        '3. Run `gctree resolve --query "<query>"`.',
+        '4. If the current repo is outside the mapped scope, choose whether to continue once, always use this gc-branch for this repo, or ignore this gc-branch here.',
+        '5. Read summaries first and only open full docs if needed.',
+        '',
+    ].join('\n');
+}
+function renderCodexOnboardSkill() {
+    const protocol = onboardingProtocolLines();
+    const completion = onboardingCompletionLines();
+    return [
+        '---',
+        'description: Guided onboarding for the active gc-branch in gctree.',
+        '---',
+        '',
+        'Use this only when the active gc-branch is empty.',
+        '',
+        '1. Run `gctree status` and explicitly state the active gc-branch to the user.',
+        ...protocol.map((line, index) => `${index + 2}. ${line}`),
+        `${protocol.length + 2}. Then create a temporary JSON file with \`branchSummary\` and \`docs[]\` (\`title\`, \`summary\`, \`body\`).`,
+        `${protocol.length + 3}. Run \`gctree __apply-onboarding --input <temp-file>\`.`,
+        ...completion.map((line, index) => `${protocol.length + index + 4}. ${line}`),
+        `${protocol.length + completion.length + 4}. If the gc-branch is not empty, stop and tell the user to run \`gctree reset-gc-branch --branch <current-gc-branch> --yes\` or \`gctree update-global-context\` instead.`,
+        '',
+    ].join('\n');
+}
+function renderCodexUpdateSkill() {
+    return [
+        '---',
+        'description: Guided durable update for the active gc-branch in gctree.',
+        '---',
+        '',
+        '1. Run `gctree status` and explicitly state the active gc-branch to the user.',
+        '2. Ask what durable context should change, one question at a time.',
+        '3. If this repo clearly belongs to the current gc-branch but is not mapped yet, ask the user whether it should be added to the branch-repo map and run `gctree set-repo-scope --branch <current-gc-branch> --include` when they approve.',
+        '4. Create a temporary JSON file containing the updated `docs[]` and optional `branchSummary`.',
+        '5. Run `gctree __apply-update --input <temp-file>`.',
+        '6. Show the updated docs back to the user.',
+        '',
+    ].join('\n');
+}
+function renderClaudeSnippet() {
+    return [
+        '# gctree Claude Code integration snippet',
+        '',
+        '- Treat the active gctree branch as a **gc-branch** in user-facing language.',
+        '- Run `gctree status` before relying on global context if the active gc-branch is unclear.',
+        '- Use `gctree resolve --query "<task>"` when reusable global context may matter.',
+        '- Use `/gc-onboard` only for an empty gc-branch.',
+        '- Use `/gc-update-global-context` when durable context in the active gc-branch should change.',
+        '',
+    ].join('\n');
+}
+function renderClaudeSessionStartHook() {
+    return [
+        '# gctree Claude Code SessionStart note',
+        '',
+        '- At session start, confirm the active gc-branch with `gctree status` when reusable global context may matter.',
+        '- Refer to gctree branches as **gc-branches** in user-facing language.',
+        '- Resolve summaries before planning or implementation when branch-level context may change the answer.',
+        '',
+    ].join('\n');
+}
+function renderClaudeResolveCommand() {
+    return [
+        '---',
+        'description: Resolve reusable global context from the active gc-branch.',
+        'argument-hint: "<query>"',
+        '---',
+        '',
+        '1. Run `gctree status` if the active gc-branch is unclear.',
+        '2. Explicitly mention the active gc-branch before using the result.',
+        '3. Run `gctree resolve --query "$ARGUMENTS"`.',
+        '4. If the current repo is outside the mapped scope, choose whether to continue once, always use this gc-branch for this repo, or ignore this gc-branch here.',
+        '5. Read summaries first and only open full docs if needed.',
+        '',
+    ].join('\n');
+}
+function renderClaudeOnboardCommand() {
+    const protocol = onboardingProtocolLines();
+    const completion = onboardingCompletionLines();
+    return [
+        '---',
+        'description: Guided onboarding for the active gc-branch in gctree.',
+        '---',
+        '',
+        'Use this only when the active gc-branch is empty.',
+        '',
+        '1. Run `gctree status` and explicitly state the active gc-branch to the user.',
+        ...protocol.map((line, index) => `${index + 2}. ${line}`),
+        `${protocol.length + 2}. Then create a temporary JSON file with \`branchSummary\` and \`docs[]\` (\`title\`, \`summary\`, \`body\`).`,
+        `${protocol.length + 3}. Run \`gctree __apply-onboarding --input <temp-file>\`.`,
+        ...completion.map((line, index) => `${protocol.length + index + 4}. ${line}`),
+        `${protocol.length + completion.length + 4}. If the gc-branch is not empty, stop and tell the user to run \`gctree reset-gc-branch --branch <current-gc-branch> --yes\` or \`gctree update-global-context\` instead.`,
+        '',
+    ].join('\n');
+}
+function renderClaudeUpdateCommand() {
+    return [
+        '---',
+        'description: Guided durable update for the active gc-branch in gctree.',
+        '---',
+        '',
+        '1. Run `gctree status` and explicitly state the active gc-branch to the user.',
+        '2. Ask what durable context should change, one question at a time.',
+        '3. If this repo clearly belongs to the current gc-branch but is not mapped yet, ask the user whether it should be added to the branch-repo map and run `gctree set-repo-scope --branch <current-gc-branch> --include` when they approve.',
+        '4. Create a temporary JSON file containing the updated `docs[]` and optional `branchSummary`.',
+        '5. Run `gctree __apply-update --input <temp-file>`.',
+        '6. Show the updated docs back to the user.',
+        '',
+    ].join('\n');
+}
+function scaffoldFiles(host) {
+    if (host === 'codex') {
+        return [
+            { path: 'AGENTS.md', content: renderCodexAgentsSnippet() },
+            { path: '.codex/prompts/gctree-bootstrap.md', content: renderCodexBootstrapPrompt() },
+            { path: '.codex/skills/gc-resolve-context/SKILL.md', content: renderCodexResolveSkill() },
+            { path: '.codex/skills/gc-onboard/SKILL.md', content: renderCodexOnboardSkill() },
+            { path: '.codex/skills/gc-update-global-context/SKILL.md', content: renderCodexUpdateSkill() },
+        ];
+    }
+    return [
+        { path: 'CLAUDE.md', content: renderClaudeSnippet() },
+        { path: '.claude/hooks/gctree-session-start.md', content: renderClaudeSessionStartHook() },
+        { path: '.claude/commands/gc-resolve-context.md', content: renderClaudeResolveCommand() },
+        { path: '.claude/commands/gc-onboard.md', content: renderClaudeOnboardCommand() },
+        { path: '.claude/commands/gc-update-global-context.md', content: renderClaudeUpdateCommand() },
+    ];
+}
+export async function scaffoldHostIntegration({ host, targetDir, force = false, }) {
+    const files = scaffoldFiles(host);
+    const written = [];
+    const skippedExisting = [];
+    const targets = files.map((file) => ({
+        ...file,
+        fullPath: join(targetDir, file.path),
+    }));
+    for (const target of targets) {
+        let exists = false;
+        try {
+            await access(target.fullPath);
+            exists = true;
+        }
+        catch {
+            exists = false;
+        }
+        if (exists && !force) {
+            skippedExisting.push(target.fullPath);
+            continue;
+        }
+        await mkdir(dirname(target.fullPath), { recursive: true });
+        await writeFile(target.fullPath, `${target.content.trimEnd()}
+`, 'utf8');
+        written.push(target.fullPath);
+    }
+    return {
+        host,
+        target_dir: targetDir,
+        written,
+        skipped_existing: skippedExisting,
+    };
+}

package/dist/src/settings.js

@@ -0,0 +1,30 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { settingsPath } from './paths.js';
+export async function readSettings(home) {
+    try {
+        const raw = await readFile(settingsPath(home), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeSettings({ home, providerMode, preferredProvider, preferredLanguage, }) {
+    await mkdir(home, { recursive: true });
+    const settings = {
+        version: 1,
+        provider_mode: providerMode,
+        preferred_provider: preferredProvider,
+        preferred_language: preferredLanguage.trim() || 'English',
+        updated_at: new Date().toISOString(),
+    };
+    await writeFile(settingsPath(home), `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    return settings;
+}
+export async function requirePreferredProvider(home) {
+    const settings = await readSettings(home);
+    if (!settings?.preferred_provider) {
+        throw new Error('preferred provider is not configured. Run `gctree init` first.');
+    }
+    return settings.preferred_provider;
+}