@ohzw/worktree-command-tui 0.1.1 → 0.1.3

package/dist/core/config-lifecycle.js

@@ -0,0 +1,160 @@
+import { readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES, parseJsonc } from './config.js';
+const SAFE_NAMESPACE_PATTERN = /^[A-Za-z0-9._-]+$/u;
+const UNSAFE_NAMESPACE_RUN_PATTERN = /[^A-Za-z0-9._-]+/gu;
+const LEADING_NAMESPACE_HYPHENS_PATTERN = /^-+/u;
+const TRAILING_NAMESPACE_HYPHENS_PATTERN = /-+$/u;
+const SAFE_NAMESPACE_DESCRIPTION = '[A-Za-z0-9._-]+';
+const DEFAULT_NAMESPACE = 'worktree-command-tui';
+const MAX_CONFIG_BYTES = 64 * 1024;
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+export function isSafeNamespace(value) {
+    return isNonEmptyString(value) && SAFE_NAMESPACE_PATTERN.test(value);
+}
+export function toSafeNamespace(value) {
+    const replaced = value.replace(UNSAFE_NAMESPACE_RUN_PATTERN, '-');
+    const trimmed = replaced.replace(LEADING_NAMESPACE_HYPHENS_PATTERN, '').replace(TRAILING_NAMESPACE_HYPHENS_PATTERN, '');
+    return isSafeNamespace(trimmed) ? trimmed : DEFAULT_NAMESPACE;
+}
+function readStringList(value, fieldName) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.some(item => !isNonEmptyString(item))) {
+        throw new Error(`${fieldName} must be a string array`);
+    }
+    return value;
+}
+function readOrphanMatchers(value) {
+    const matchers = readStringList(value, 'orphanMatchers');
+    for (const matcher of matchers) {
+        if (!/\S+\s+\S+/u.test(matcher)) {
+            throw new Error('orphanMatchers entries must include a command plus argument fragment');
+        }
+    }
+    return matchers;
+}
+function readRequiredCommand(value, fieldName) {
+    if (!Array.isArray(value) || value.length === 0 || value.some(part => !isNonEmptyString(part))) {
+        throw new Error(`${fieldName} must be a non-empty string array`);
+    }
+    return value;
+}
+function readOptionalCommand(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.length === 0 || value.some(part => !isNonEmptyString(part))) {
+        throw new Error(`${fieldName} must be a non-empty string array when set`);
+    }
+    return value;
+}
+function readPort(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535) {
+        throw new Error('port must be an integer between 1 and 65535');
+    }
+    return value;
+}
+export function validateToolConfig(raw) {
+    const config = (raw ?? {});
+    const command = readRequiredCommand(config.command, 'command');
+    if (!isSafeNamespace(config.namespace)) {
+        throw new Error(`namespace must match ${SAFE_NAMESPACE_DESCRIPTION}`);
+    }
+    return {
+        namespace: config.namespace,
+        command,
+        setupCommand: readOptionalCommand(config.setupCommand, 'setupCommand'),
+        editorCommand: readOptionalCommand(config.editorCommand, 'editorCommand'),
+        port: readPort(config.port),
+        requiredFiles: readStringList(config.requiredFiles, 'requiredFiles'),
+        orphanMatchers: readOrphanMatchers(config.orphanMatchers),
+    };
+}
+export function createDefaultToolConfig(options) {
+    return validateToolConfig({
+        namespace: toSafeNamespace(options.namespaceSeed),
+        command: [options.packageManager, 'run', options.script],
+        setupCommand: [options.packageManager, 'install'],
+        editorCommand: ['code'],
+        port: 3000,
+        requiredFiles: ['package.json'],
+        orphanMatchers: [],
+    });
+}
+async function readConfigFile(configPath) {
+    if ((await stat(configPath)).size > MAX_CONFIG_BYTES) {
+        throw new Error('config file is too large');
+    }
+    return readFile(configPath, 'utf8');
+}
+async function readFirstConfig(repoRoot) {
+    let firstError;
+    for (const fileName of CONFIG_FILE_NAMES) {
+        try {
+            return await readConfigFile(path.join(repoRoot, fileName));
+        }
+        catch (error) {
+            firstError ??= error;
+        }
+    }
+    throw firstError;
+}
+export async function loadToolConfig({ repoRoot }) {
+    return validateToolConfig(parseJsonc(await readFirstConfig(repoRoot)));
+}
+export function renderConfigJsonc(config) {
+    const setupCommandSection = config.setupCommand === undefined ? '' : `
+  // Optional command run manually with the setup key in the selected worktree.
+  // Review before running in untrusted worktrees; package installs may run lifecycle scripts.
+  "setupCommand": ${JSON.stringify(config.setupCommand)},
+`;
+    const editorCommandSection = config.editorCommand === undefined ? '' : `
+  // Optional command that opens the selected worktree path in an editor.
+  // The selected worktree path is appended as the final argv entry.
+  "editorCommand": ${JSON.stringify(config.editorCommand)},
+`;
+    return `{
+  // Session namespace used for git-common-dir state files and logs.
+  // Keep this filesystem-safe: letters, numbers, dots, underscores, and hyphens only.
+  "namespace": ${JSON.stringify(config.namespace)},
+
+  // Command launched in the selected worktree when you press Enter.
+  // Treat this config as trusted code. argv form avoids shell metacharacter expansion.
+  "command": ${JSON.stringify(config.command)},
+${setupCommandSection}${editorCommandSection}
+  // TCP port owned by the command, used when stopping stale/orphaned processes.
+  "port": ${JSON.stringify(config.port)},
+
+  // Files that must exist in a worktree before the command can be started there.
+  "requiredFiles": ${JSON.stringify(config.requiredFiles)},
+
+  // Extra command-line substrings for cleanup within the recorded process group only.
+  // Include a command plus argument fragment; broad single-token matchers are rejected.
+  // Example: ["node --watch", "vite --host 0.0.0.0"]
+  "orphanMatchers": ${JSON.stringify(config.orphanMatchers)},
+}
+`;
+}
+export async function findExistingConfigPath(workspaceRoot, fileExists) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+        const configPath = path.join(workspaceRoot, fileName);
+        if (await fileExists(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+export async function writeToolConfigForRepo({ workspaceRoot, force, config }, fileExists) {
+    const configPath = path.join(workspaceRoot, CONFIG_FILE_NAME);
+    const existingConfigPath = await findExistingConfigPath(workspaceRoot, fileExists);
+    if (!force && existingConfigPath) {
+        throw new Error(`Config file already exists: ${existingConfigPath}`);
+    }
+    const validatedConfig = validateToolConfig(config);
+    await writeFile(configPath, renderConfigJsonc(validatedConfig), 'utf8');
+    return { path: configPath, config: validatedConfig };
+}

package/dist/core/config.d.ts

@@ -4,11 +4,10 @@ export declare const CONFIG_FILE_NAMES: readonly [".worktree-command-tui.jsonc",
 export interface ToolConfig {
     namespace: string;
     command: string[];
+    setupCommand?: string[];
+    editorCommand?: string[];
     port: number;
     requiredFiles: string[];
     orphanMatchers: string[];
 }
 export declare function parseJsonc(source: string): unknown;
-export declare function loadToolConfig({ repoRoot }: {
-    repoRoot: string;
-}): Promise<ToolConfig>;

package/dist/core/config.js

@@ -1,23 +1,6 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
 export const CONFIG_FILE_NAME = '.worktree-command-tui.jsonc';
 export const LEGACY_CONFIG_FILE_NAME = '.worktree-command-tui.json';
 export const CONFIG_FILE_NAMES = [CONFIG_FILE_NAME, LEGACY_CONFIG_FILE_NAME];
-function isNonEmptyString(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-function isSafeNamespace(value) {
-    return isNonEmptyString(value) && /^[A-Za-z0-9._-]+$/u.test(value);
-}
-function readStringList(value, fieldName) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value) || value.some(item => !isNonEmptyString(item))) {
-        throw new Error(`${fieldName} must be a string array`);
-    }
-    return value;
-}
 function stripJsoncComments(source) {
     let result = '';
     let inString = false;
@@ -119,34 +102,3 @@ function stripTrailingCommas(source) {
 export function parseJsonc(source) {
     return JSON.parse(stripTrailingCommas(stripJsoncComments(source)));
 }
-async function readFirstConfig(repoRoot) {
-    let firstError;
-    for (const fileName of CONFIG_FILE_NAMES) {
-        try {
-            return await readFile(path.join(repoRoot, fileName), 'utf8');
-        }
-        catch (error) {
-            firstError ??= error;
-        }
-    }
-    throw firstError;
-}
-export async function loadToolConfig({ repoRoot }) {
-    const raw = parseJsonc(await readFirstConfig(repoRoot));
-    if (!Array.isArray(raw.command) || raw.command.length === 0 || raw.command.some(part => !isNonEmptyString(part))) {
-        throw new Error('command must be a non-empty string array');
-    }
-    if (!isSafeNamespace(raw.namespace)) {
-        throw new Error('namespace must match [A-Za-z0-9._-]+');
-    }
-    if (typeof raw.port !== 'number' || !Number.isInteger(raw.port) || raw.port < 1 || raw.port > 65535) {
-        throw new Error('port must be an integer between 1 and 65535');
-    }
-    return {
-        namespace: raw.namespace,
-        command: raw.command,
-        port: raw.port,
-        requiredFiles: readStringList(raw.requiredFiles, 'requiredFiles'),
-        orphanMatchers: readStringList(raw.orphanMatchers, 'orphanMatchers'),
-    };
-}

package/dist/core/git-metadata.d.ts

@@ -0,0 +1,25 @@
+export interface UpstreamInfo {
+    branch: string;
+    ahead: number;
+    behind: number;
+}
+export interface WorkingTreeInfo {
+    staged: number;
+    unstaged: number;
+    untracked: number;
+    conflicts: number;
+}
+export interface GitStatusSummary {
+    upstream?: UpstreamInfo;
+    upstreamUnavailable: boolean;
+    workingTree?: WorkingTreeInfo;
+}
+export interface RepoContext {
+    workspaceRoot: string;
+    mainWorktreePath: string;
+    gitCommonDir: string;
+}
+export declare function parseGitStatusSummary(output: string): GitStatusSummary;
+export declare function readGitStatusSummary(cwd: string): Promise<GitStatusSummary>;
+export declare function readBranchCreatedAtMs(cwd: string, branch: string): Promise<number | null>;
+export declare function resolveRepoContext(cwd: string): Promise<RepoContext>;

package/dist/core/git-metadata.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+function createEmptyWorkingTree() {
+    return { staged: 0, unstaged: 0, untracked: 0, conflicts: 0 };
+}
+export function parseGitStatusSummary(output) {
+    const workingTree = createEmptyWorkingTree();
+    let upstreamBranch;
+    let ahead = 0;
+    let behind = 0;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('# branch.upstream ')) {
+            upstreamBranch = line.slice('# branch.upstream '.length).trim();
+            continue;
+        }
+        if (line.startsWith('# branch.ab ')) {
+            const match = /# branch\.ab \+(\d+) -(\d+)/.exec(line);
+            ahead = Number(match?.[1] ?? 0);
+            behind = Number(match?.[2] ?? 0);
+            continue;
+        }
+        if (line.startsWith('1 ') || line.startsWith('2 ')) {
+            const [, xy = '..'] = line.split(' ', 3);
+            if (xy[0] !== '.') {
+                workingTree.staged += 1;
+            }
+            if (xy[1] !== '.') {
+                workingTree.unstaged += 1;
+            }
+            continue;
+        }
+        if (line.startsWith('u ')) {
+            workingTree.conflicts += 1;
+            continue;
+        }
+        if (line.startsWith('? ')) {
+            workingTree.untracked += 1;
+        }
+    }
+    return {
+        upstream: upstreamBranch ? { branch: upstreamBranch, ahead, behind } : undefined,
+        upstreamUnavailable: false,
+        workingTree,
+    };
+}
+export async function readGitStatusSummary(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--branch', '--porcelain=v2'], { cwd });
+        return parseGitStatusSummary(stdout);
+    }
+    catch {
+        return { upstreamUnavailable: true };
+    }
+}
+export async function readBranchCreatedAtMs(cwd, branch) {
+    if (branch.startsWith('(')) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync('git', ['reflog', 'show', '--format=%ct', `refs/heads/${branch}`], { cwd });
+        const trimmed = stdout.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        const timestamps = trimmed.split('\n');
+        const firstTimestampSeconds = Number(timestamps.at(-1));
+        return Number.isFinite(firstTimestampSeconds) ? firstTimestampSeconds * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveRepoContext(cwd) {
+    const [{ stdout: workspaceRootRaw }, { stdout: gitCommonDirRaw }] = await Promise.all([
+        execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),
+        execFileAsync('git', ['rev-parse', '--git-common-dir'], { cwd }),
+    ]);
+    const workspaceRoot = workspaceRootRaw.trim();
+    const gitCommonDir = path.resolve(workspaceRoot, gitCommonDirRaw.trim());
+    const mainWorktreePath = path.dirname(gitCommonDir);
+    return { workspaceRoot, mainWorktreePath, gitCommonDir };
+}

package/dist/core/git-worktrees.d.ts

@@ -4,8 +4,9 @@ export interface WorktreeRow {
     headSha: string;
     isMain: boolean;
     isExternal: boolean;
+    createdAtMs: number | null;
 }
 export declare function parseWorktreeListPorcelain(input: string, mainWorktreePath: string): WorktreeRow[];
-export declare function sortWorktrees(rows: WorktreeRow[], activePath: string | null): WorktreeRow[];
+export declare function sortWorktrees(rows: WorktreeRow[], _activePath: string | null): WorktreeRow[];
 export declare function readWorktrees(cwd: string, mainWorktreePath: string): Promise<WorktreeRow[]>;
 export declare function toShortPath(mainWorktreePath: string, worktreePath: string): string;

package/dist/core/git-worktrees.js

@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
@@ -28,26 +29,44 @@ export function parseWorktreeListPorcelain(input, mainWorktreePath) {
             headSha: headLine?.slice('HEAD '.length) ?? '',
             isMain: worktreePath === mainWorktreePath,
             isExternal: isExternalWorktree(mainWorktreePath, worktreePath),
+            createdAtMs: null,
         };
     });
 }
-export function sortWorktrees(rows, activePath) {
+function compareDeterministic(left, right) {
+    if (left.isMain !== right.isMain) {
+        return left.isMain ? -1 : 1;
+    }
+    const branchCompare = left.branch.localeCompare(right.branch);
+    return branchCompare !== 0 ? branchCompare : left.path.localeCompare(right.path);
+}
+export function sortWorktrees(rows, _activePath) {
+    const hasMissingCreatedAt = rows.some(row => row.createdAtMs === null);
     return [...rows].sort((left, right) => {
-        if (left.isMain !== right.isMain) {
-            return left.isMain ? -1 : 1;
-        }
-        const leftActive = activePath !== null && left.path === activePath;
-        const rightActive = activePath !== null && right.path === activePath;
-        if (leftActive !== rightActive) {
-            return leftActive ? -1 : 1;
+        const leftCreated = left.createdAtMs;
+        const rightCreated = right.createdAtMs;
+        if (!hasMissingCreatedAt && leftCreated !== null && rightCreated !== null && leftCreated !== rightCreated) {
+            return leftCreated - rightCreated;
         }
-        const branchCompare = left.branch.localeCompare(right.branch);
-        return branchCompare !== 0 ? branchCompare : left.path.localeCompare(right.path);
+        return compareDeterministic(left, right);
     });
 }
+async function readWorktreeCreatedAtMs(worktreePath) {
+    try {
+        const stats = await stat(worktreePath);
+        return stats.birthtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
 export async function readWorktrees(cwd, mainWorktreePath) {
     const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd });
-    return parseWorktreeListPorcelain(stdout, mainWorktreePath);
+    const rows = parseWorktreeListPorcelain(stdout, mainWorktreePath);
+    return Promise.all(rows.map(async (row) => ({
+        ...row,
+        createdAtMs: await readWorktreeCreatedAtMs(row.path),
+    })));
 }
 export function toShortPath(mainWorktreePath, worktreePath) {
     if (worktreePath === mainWorktreePath) {

package/dist/core/github-metadata.d.ts

@@ -0,0 +1,21 @@
+export interface GitHubRepository {
+    host: string;
+    owner: string;
+    name: string;
+}
+export type PullRequestInfo = {
+    kind: 'found';
+    number: number;
+    title: string;
+    url: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    isDraft: boolean;
+    baseBranch: string;
+} | {
+    kind: 'none';
+} | {
+    kind: 'unavailable';
+};
+export declare function isGitHubMetadataHostAllowed(host: string): boolean;
+export declare function normalizePullRequestUrlForRepository(url: string, repository: GitHubRepository, number: number): string | null;
+export declare function readPullRequestInfo(cwd: string, branch: string): Promise<PullRequestInfo>;

package/dist/core/github-metadata.js

@@ -0,0 +1,153 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const GH_TIMEOUT_MS = 2500;
+const SCP_REMOTE_URL_RE = /^(?:[^@]+@)?([^:]+):(.+)$/;
+function splitRepositoryPath(pathInput) {
+    return pathInput
+        .replace(/\.git$/, '')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .split('/')
+        .filter(Boolean);
+}
+function parseGitHubRepositoryFromRemoteUrl(remoteUrl) {
+    const trimmedUrl = remoteUrl.trim();
+    if (!trimmedUrl) {
+        return null;
+    }
+    if (trimmedUrl.includes('://')) {
+        if (!URL.canParse(trimmedUrl)) {
+            return null;
+        }
+        const parsedUrl = new URL(trimmedUrl);
+        const segments = splitRepositoryPath(parsedUrl.pathname);
+        if (segments.length < 2) {
+            return null;
+        }
+        return { host: parsedUrl.hostname.toLowerCase(), owner: segments[0], name: segments[1] };
+    }
+    const scpMatch = SCP_REMOTE_URL_RE.exec(trimmedUrl);
+    if (!scpMatch) {
+        return null;
+    }
+    const segments = splitRepositoryPath(scpMatch[2]);
+    if (segments.length < 2) {
+        return null;
+    }
+    return { host: scpMatch[1].toLowerCase(), owner: segments[0], name: segments[1] };
+}
+export function isGitHubMetadataHostAllowed(host) {
+    return host.toLowerCase() === 'github.com';
+}
+export function normalizePullRequestUrlForRepository(url, repository, number) {
+    if (!URL.canParse(url)) {
+        return null;
+    }
+    const parsedUrl = new URL(url);
+    const expectedPath = `/${repository.owner}/${repository.name}/pull/${number}`;
+    if (parsedUrl.protocol !== 'https:'
+        || parsedUrl.hostname.toLowerCase() !== repository.host
+        || parsedUrl.pathname !== expectedPath
+        || parsedUrl.search !== ''
+        || parsedUrl.hash !== '') {
+        return null;
+    }
+    return `https://${repository.host}${expectedPath}`;
+}
+async function readGitHubRepository(cwd) {
+    const { stdout } = await execFileAsync('git', ['config', '--get', 'remote.origin.url'], { cwd });
+    const repository = parseGitHubRepositoryFromRemoteUrl(stdout);
+    if (!repository || !isGitHubMetadataHostAllowed(repository.host)) {
+        throw new Error('GitHub repository remote unavailable');
+    }
+    return repository;
+}
+function buildPullRequestListArgs(repository, branch, state) {
+    const args = [
+        'api',
+        '-X',
+        'GET',
+        `repos/${repository.owner}/${repository.name}/pulls`,
+        '-f',
+        `state=${state}`,
+        '-f',
+        `head=${repository.owner}:${branch}`,
+        '-F',
+        'per_page=1',
+    ];
+    args.push('--hostname', repository.host);
+    return args;
+}
+function normalizePullRequestState(state, mergedAt) {
+    if (typeof state === 'string' && state.toUpperCase() === 'OPEN') {
+        return 'OPEN';
+    }
+    return typeof mergedAt === 'string' && mergedAt.length > 0 ? 'MERGED' : 'CLOSED';
+}
+function parsePullRequest(item, repository) {
+    if (typeof item !== 'object' || item === null) {
+        return null;
+    }
+    const pullRequest = item;
+    const number = typeof pullRequest.number === 'number' ? pullRequest.number : NaN;
+    const title = typeof pullRequest.title === 'string' ? pullRequest.title : '';
+    const url = typeof pullRequest.html_url === 'string' && Number.isFinite(number) ? normalizePullRequestUrlForRepository(pullRequest.html_url, repository, number) : null;
+    const isDraft = typeof pullRequest.draft === 'boolean' ? pullRequest.draft : false;
+    const baseRefName = typeof pullRequest.base?.ref === 'string' ? pullRequest.base.ref : '';
+    if (!Number.isFinite(number) || !title || url === null || !baseRefName) {
+        return null;
+    }
+    return {
+        number,
+        title,
+        url,
+        state: normalizePullRequestState(pullRequest.state, pullRequest.merged_at),
+        isDraft,
+        baseRefName,
+    };
+}
+async function readPullRequestList(cwd, branch, state) {
+    const repository = await readGitHubRepository(cwd);
+    const args = buildPullRequestListArgs(repository, branch, state);
+    const { stdout } = await execFileAsync('gh', args, { cwd, timeout: GH_TIMEOUT_MS });
+    const payload = JSON.parse(stdout);
+    if (!Array.isArray(payload)) {
+        throw new Error('GitHub REST API returned unexpected payload');
+    }
+    const pullRequests = [];
+    for (const item of payload) {
+        const parsed = parsePullRequest(item, repository);
+        if (parsed !== null) {
+            pullRequests.push(parsed);
+        }
+    }
+    return pullRequests;
+}
+export async function readPullRequestInfo(cwd, branch) {
+    if (branch.startsWith('(')) {
+        return { kind: 'none' };
+    }
+    try {
+        const openPullRequests = await readPullRequestList(cwd, branch, 'open');
+        const pullRequests = openPullRequests.length > 0
+            ? openPullRequests
+            : await readPullRequestList(cwd, branch, 'all');
+        const pullRequest = pullRequests[0];
+        if (!pullRequest) {
+            return { kind: 'none' };
+        }
+        return {
+            kind: 'found',
+            number: pullRequest.number,
+            title: pullRequest.title,
+            url: pullRequest.url,
+            state: pullRequest.state,
+            isDraft: pullRequest.isDraft,
+            baseBranch: pullRequest.baseRefName,
+        };
+    }
+    catch {
+        return { kind: 'unavailable' };
+    }
+}

package/dist/core/init.d.ts

@@ -1,6 +1,7 @@
-import { type ToolConfig } from './config.js';
+import type { ToolConfig } from './config.js';
+import { renderConfigJsonc } from './config-lifecycle.js';
+export { renderConfigJsonc };
 export declare function buildDefaultConfig(repoRoot: string): Promise<ToolConfig>;
-export declare function renderConfigJsonc(config: ToolConfig): string;
 export interface InitResult {
     path: string;
     config: ToolConfig;