@technomoron/agent-run 0.99.23 → 0.99.25

package/dist/commands.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = require("fs");
+const path = require("path");
+const checks_1 = require("./checks");
+const cli_1 = require("./cli");
+const config_tree_1 = require("./config-tree");
+const constants_1 = require("./constants");
+const manifest_1 = require("./manifest");
+const process_1 = require("./process");
+const project_1 = require("./project");
+const renderer_1 = require("./renderer");
+const tools_1 = require("./tools");
+const utils_1 = require("./utils");
+function main(invokedTool, argv) {
+    dispatch((0, cli_1.parseInvocation)(invokedTool, argv));
+}
+function dispatch(command) {
+    switch (command.command) {
+        case 'check':
+            runCheck(command);
+            return;
+        case 'init':
+            runInit(command);
+            return;
+        case 'init-config':
+            runInitConfig(command);
+            return;
+        case 'edit':
+            runEdit(command);
+            return;
+        case 'update':
+            runUpdate(command);
+            return;
+        case 'migrate-config':
+            runMigrateConfig(command);
+            return;
+        default:
+            runTool(command);
+    }
+}
+function runTool(parsed) {
+    const { args, command, wrapperArgs } = parsed;
+    const projectRoot = (0, project_1.findProjectRoot)(process.cwd());
+    (0, utils_1.verbose)(`run ${command}: cwd=${process.cwd()} projectRoot=${projectRoot}`);
+    validateRunModes(parsed, projectRoot);
+    if (wrapperArgs.none || (0, project_1.isIgnoredDir)(projectRoot)) {
+        (0, utils_1.verbose)(`wrapper bypassed for ${command}${wrapperArgs.none ? ' via --none' : ' because project is ignored'}`);
+        (0, process_1.execTool)((0, process_1.findRealBinary)(command), [...(0, tools_1.getPermissionArgs)(command), ...args]);
+        return;
+    }
+    const profileResult = (0, project_1.resolveProfileResult)(projectRoot);
+    if (profileResult.profile === null) {
+        (0, utils_1.fail)(profileResult.reason);
+    }
+    const profile = profileResult.profile;
+    if (wrapperArgs.show) {
+        const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
+        const agentDir = path.join(configRoot, profile);
+        (0, utils_1.verbose)(`profile=${profile} configRoot=${configRoot} agentPath=${agentDir}`);
+        requireProfile(command, agentDir);
+        showToolProfile(command, projectRoot, agentDir);
+        return;
+    }
+    if (wrapperArgs.create) {
+        runInit({ command: 'init', targetPath: projectRoot });
+    }
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
+    const agentDir = path.join(configRoot, profile);
+    (0, utils_1.verbose)(`profile=${profile} configRoot=${configRoot} agentPath=${agentDir}`);
+    prepareConfigRoot(configRoot);
+    requireProfile(command, agentDir);
+    const preview = (0, renderer_1.renderProfile)(projectRoot, agentDir, true, command);
+    ensureToolEnabled(preview.context, command);
+    if (wrapperArgs.generate) {
+        printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
+        return;
+    }
+    checkLocalAiFiles(command, projectRoot, agentDir, preview.context, wrapperArgs.local);
+    const realBinary = (0, process_1.findRealBinary)(command);
+    const permissionArgs = (0, tools_1.getPermissionArgs)(command);
+    const rendered = (0, renderer_1.syncAgentProfile)(projectRoot, agentDir);
+    if (command === 'codex') {
+        (0, tools_1.runCodex)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
+    }
+    else {
+        (0, tools_1.runClaude)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
+    }
+}
+function validateRunModes(parsed, projectRoot) {
+    const { command, wrapperArgs } = parsed;
+    if (wrapperArgs.show && wrapperArgs.none) {
+        (0, utils_1.fail)('--show cannot be combined with --none');
+    }
+    if (wrapperArgs.generate && wrapperArgs.none) {
+        (0, utils_1.fail)('--generate cannot be combined with --none');
+    }
+    if (wrapperArgs.generate && wrapperArgs.show) {
+        (0, utils_1.fail)('--generate cannot be combined with --show');
+    }
+    if ((wrapperArgs.show || wrapperArgs.generate) && (0, project_1.isIgnoredDir)(projectRoot)) {
+        (0, utils_1.fail)(`cannot ${wrapperArgs.show ? 'show' : 'generate'} generated ${command} files for ignored project: ${projectRoot}`);
+    }
+}
+function requireProfile(tool, agentDir) {
+    if ((0, manifest_1.isProfileConfigured)(agentDir)) {
+        return;
+    }
+    const label = tool ?? 'agent';
+    process.stderr.write(`agent-run: no ${label} profile found for this project: ${agentDir}\n`);
+    process.stderr.write('agent-run: run `agent-run init` or use the tool with `--create`.\n');
+    process.exit(1);
+}
+function checkLocalAiFiles(command, projectRoot, agentDir, context, allowLocal) {
+    const files = (0, project_1.findLocalAiFiles)(projectRoot, agentDir);
+    if (!context.guardrails.forbidRepoAiFiles || files.length === 0) {
+        return;
+    }
+    if (!allowLocal) {
+        (0, project_1.failForLocalAiFiles)(command, projectRoot, files);
+    }
+    (0, project_1.warnForLocalAiFiles)(command, projectRoot, files);
+}
+function showToolProfile(command, projectRoot, agentDir) {
+    const trace = { sourceFiles: new Set() };
+    const rendered = (0, renderer_1.renderProfile)(projectRoot, agentDir, true, command, trace);
+    ensureToolEnabled(rendered.context, command);
+    process.stdout.write([
+        `Agent: ${command}`,
+        `Profile: ${rendered.profile}`,
+        `Project root: ${projectRoot}`,
+        `Profile dir: ${agentDir}`,
+        '',
+        'Reads/includes:',
+        ...(0, utils_1.formatPathList)((0, utils_1.uniqueSorted)([...trace.sourceFiles])),
+        '',
+        'Generates:',
+        ...(0, utils_1.formatPathList)((0, utils_1.uniqueSorted)(rendered.files.map((file) => file.path))),
+        ''
+    ].join('\n'));
+}
+function ensureToolEnabled(context, command) {
+    if (!context.tools[command]) {
+        (0, utils_1.fail)(`${command} is disabled for agent-run profile ${context.profile}`);
+    }
+}
+function runInit(parsed) {
+    const projectRoot = activeProject(parsed.targetPath, 'init');
+    if (projectRoot === null) {
+        return;
+    }
+    const agentDir = initializeProfileSource(projectRoot, true);
+    printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
+}
+function runInitConfig(parsed) {
+    const sourcePath = (0, config_tree_1.starterConfigRootPath)();
+    if (!fs.existsSync(sourcePath)) {
+        (0, utils_1.fail)(`starter config skeleton not found: ${sourcePath}`);
+    }
+    (0, config_tree_1.copySkeletonTree)(sourcePath, path.resolve(parsed.targetPath));
+    process.stdout.write(`OK copied starter config to ${path.resolve(parsed.targetPath)}\n`);
+}
+function runEdit(parsed) {
+    const projectRoot = activeProject(parsed.targetPath, 'edit');
+    if (projectRoot === null) {
+        return;
+    }
+    const agentDir = initializeProfileSource(projectRoot, false);
+    const editPath = (0, manifest_1.createDefaultLocalFile)(agentDir);
+    (0, renderer_1.syncAgentProfile)(projectRoot, agentDir);
+    process.stdout.write(`Edit: ${editPath}\n`);
+    (0, process_1.openEditor)(editPath);
+}
+function runUpdate(parsed) {
+    if (parsed.all) {
+        runUpdateAll(parsed.targetPath);
+        return;
+    }
+    const projectRoot = (0, project_1.findProjectRoot)(parsed.targetPath);
+    (0, utils_1.verbose)(`update target=${parsed.targetPath} projectRoot=${projectRoot}`);
+    if ((0, project_1.isIgnoredDir)(projectRoot)) {
+        process.stdout.write(`SKIP ignored ${projectRoot}\n`);
+        return;
+    }
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
+    const agentDir = (0, project_1.resolveAgentDir)(projectRoot);
+    prepareConfigRoot(configRoot);
+    requireProfile(null, agentDir);
+    printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
+}
+function runUpdateAll(targetPath) {
+    const configRoot = targetPath === path.resolve(process.cwd()) ? (0, project_1.defaultConfigRoot)() : path.resolve(targetPath);
+    if (!fs.existsSync(configRoot)) {
+        (0, utils_1.fail)(`missing config root: ${configRoot}`);
+    }
+    prepareConfigRoot(configRoot);
+    const profileDirs = (0, config_tree_1.findProfileDirs)(configRoot);
+    for (const agentDir of profileDirs) {
+        const profile = path.relative(configRoot, agentDir).replace(/\\/g, '/');
+        const projectRoot = (0, project_1.projectRootForProfile)(profile, configRoot);
+        (0, renderer_1.syncAgentProfile)(projectRoot, agentDir, { configRoot, profile });
+        process.stdout.write(`OK ${profile}\n`);
+    }
+    process.stdout.write(`Updated profiles: ${profileDirs.length}\n`);
+}
+function runMigrateConfig(parsed) {
+    const configRoot = parsed.configRoot;
+    if (!fs.existsSync(configRoot)) {
+        (0, utils_1.fail)(`missing config root: ${configRoot}`);
+    }
+    (0, config_tree_1.ensureConfigRootLayout)(configRoot);
+    (0, config_tree_1.ensureConfigRootGitignore)(configRoot);
+    (0, config_tree_1.migrateOldTemplates)(configRoot);
+    (0, config_tree_1.ensureDefaultGlobalTemplates)(configRoot);
+    (0, manifest_1.ensureRootDefaultsFile)(configRoot);
+    const profileDirs = (0, config_tree_1.findLegacyProfileDirs)(configRoot);
+    let createdManifestCount = 0;
+    let createdLocalCount = 0;
+    let movedRuntimeCount = 0;
+    let movedReviewCount = 0;
+    let movedMemoryCount = 0;
+    for (const agentDir of profileDirs) {
+        const localPath = path.join(agentDir, constants_1.LOCAL_TEMPLATE_FILE_NAME);
+        if (!fs.existsSync(localPath)) {
+            fs.writeFileSync(localPath, (0, config_tree_1.convertLegacyTemplateVars)(fs.readFileSync(path.join(agentDir, 'AGENTS-MODS.md'), 'utf8')), 'utf8');
+            createdLocalCount += 1;
+        }
+        if (!fs.existsSync(path.join(agentDir, constants_1.MANIFEST_FILE_NAME))) {
+            (0, manifest_1.createProfileMarker)(agentDir);
+            createdManifestCount += 1;
+        }
+        movedRuntimeCount += (0, config_tree_1.migrateCodexRuntimeFiles)(agentDir);
+        movedReviewCount += (0, config_tree_1.migrateLooseFiles)(agentDir, /^REVIEW(?:-.+)?\.md$/, 'reviews');
+        movedMemoryCount += (0, config_tree_1.migrateLooseFiles)(agentDir, /^memory.*\.md$/i, 'memories');
+    }
+    process.stdout.write(`OK migrated ${configRoot}\n`);
+    process.stdout.write(`Profiles converted: ${profileDirs.length}\n`);
+    process.stdout.write(`Created local.md.njk: ${createdLocalCount}\n`);
+    process.stdout.write(`Created agent-run.jsonc: ${createdManifestCount}\n`);
+    process.stdout.write(`Moved Codex runtime entries: ${movedRuntimeCount}\n`);
+    process.stdout.write(`Moved review files: ${movedReviewCount}\n`);
+    process.stdout.write(`Moved memory files: ${movedMemoryCount}\n`);
+}
+function runCheck(parsed) {
+    if (parsed.all) {
+        const report = (0, checks_1.checkSourceTree)(parsed.targetPath);
+        (0, checks_1.printBatchReport)(report.root, report.entries);
+        process.exit(report.hasErrors ? 1 : 0);
+    }
+    const projectRoot = (0, project_1.findProjectRoot)(parsed.targetPath);
+    if ((0, project_1.isIgnoredDir)(projectRoot)) {
+        process.stdout.write(`Check: ${projectRoot}\nSKIP ignored by .agent-run-ignore\n`);
+        process.exit(0);
+    }
+    const findings = (0, checks_1.checkProject)(projectRoot);
+    (0, checks_1.printProjectReport)(projectRoot, findings);
+    process.exit((0, checks_1.hasErrors)(findings) ? 1 : 0);
+}
+function prepareConfigRoot(configRoot) {
+    (0, config_tree_1.ensureConfigRootLayout)(configRoot);
+    (0, config_tree_1.ensureConfigRootGitignore)(configRoot);
+    (0, config_tree_1.ensureDefaultGlobalTemplates)(configRoot);
+}
+function activeProject(targetPath, action) {
+    const projectRoot = (0, project_1.findProjectRoot)(targetPath);
+    (0, utils_1.verbose)(`${action} target=${targetPath} projectRoot=${projectRoot}`);
+    if (!(0, project_1.isIgnoredDir)(projectRoot)) {
+        return projectRoot;
+    }
+    process.stdout.write(`SKIP ignored ${projectRoot}\n`);
+    return null;
+}
+function initializeProfileSource(projectRoot, preferProjectConfigRoot) {
+    const profile = (0, project_1.resolveProfile)(projectRoot);
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot, { preferProjectRoot: preferProjectConfigRoot });
+    const agentDir = path.join(configRoot, profile);
+    prepareConfigRoot(configRoot);
+    (0, manifest_1.ensureRootDefaultsFile)(configRoot);
+    fs.mkdirSync(agentDir, { recursive: true });
+    (0, manifest_1.convertLegacyProfileIfNeeded)(agentDir);
+    (0, manifest_1.createProfileMarker)(agentDir);
+    return agentDir;
+}
+function printUpdateSummary(rendered) {
+    process.stdout.write(`OK profile ${rendered.profile}\n`);
+    process.stdout.write(`Profile dir: ${rendered.agentDir}\n`);
+    process.stdout.write(`Live dir: ${rendered.context.paths.liveDir}\n`);
+    process.stdout.write(`Generated files: ${rendered.files.length}\n`);
+    process.stdout.write(`Installed skills: ${rendered.skills.map((skill) => skill.name).join(', ') || '(none)'}\n`);
+}

package/dist/config-tree.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureConfigRootLayout = ensureConfigRootLayout;
+exports.ensureConfigRootGitignore = ensureConfigRootGitignore;
+exports.ensureDefaultGlobalTemplates = ensureDefaultGlobalTemplates;
+exports.migrateOldTemplates = migrateOldTemplates;
+exports.findLegacyProfileDirs = findLegacyProfileDirs;
+exports.findProfileDirs = findProfileDirs;
+exports.convertLegacyTemplateVars = convertLegacyTemplateVars;
+exports.migrateCodexRuntimeFiles = migrateCodexRuntimeFiles;
+exports.migrateLooseFiles = migrateLooseFiles;
+exports.starterConfigRootPath = starterConfigRootPath;
+exports.copySkeletonTree = copySkeletonTree;
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("./constants");
+const defaults_1 = require("./defaults");
+const utils_1 = require("./utils");
+const walk_tree_1 = require("./walk-tree");
+const PRUNED_CONFIG_DIRS = new Set([
+    '.git',
+    'orphaned',
+    'global',
+    'templates',
+    '.agents',
+    '.claude',
+    '.codex',
+    'bin',
+    'reviews',
+    'memories',
+    'cache',
+    'log',
+    'sessions',
+    'shell_snapshots',
+    'skills',
+    'tmp',
+    '.tmp'
+]);
+function ensureConfigRootLayout(configRoot) {
+    fs.mkdirSync(configRoot, { recursive: true });
+}
+function ensureConfigRootGitignore(configRoot) {
+    fs.mkdirSync(configRoot, { recursive: true });
+    const gitignorePath = path.join(configRoot, '.gitignore');
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8').replace(/\r\n/g, '\n') : '';
+    const lines = existing.length > 0 ? existing.replace(/\n+$/, '').split('\n') : [];
+    const present = new Set(lines);
+    let changed = !fs.existsSync(gitignorePath);
+    for (const entry of constants_1.GENERATED_GITIGNORE_ENTRIES) {
+        if (entry === '' || present.has(entry)) {
+            continue;
+        }
+        lines.push(entry);
+        present.add(entry);
+        changed = true;
+    }
+    if (changed) {
+        fs.writeFileSync(gitignorePath, `${lines.join('\n')}\n`, 'utf8');
+    }
+}
+function ensureDefaultGlobalTemplates(configRoot) {
+    for (const [relativePath, content] of (0, defaults_1.defaultGlobalTemplates)()) {
+        const filePath = path.join(configRoot, relativePath);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, content, 'utf8');
+            (0, utils_1.verbose)(`created ${filePath}`);
+        }
+    }
+}
+function migrateOldTemplates(configRoot) {
+    const oldCodeTemplate = path.join(configRoot, 'templates', 'AGENTS-CODE.md');
+    const newCodeTemplate = path.join(configRoot, 'global', 'agents', 'code.md.njk');
+    if (!fs.existsSync(oldCodeTemplate) || fs.existsSync(newCodeTemplate)) {
+        return;
+    }
+    fs.mkdirSync(path.dirname(newCodeTemplate), { recursive: true });
+    fs.writeFileSync(newCodeTemplate, convertLegacyTemplateVars(fs.readFileSync(oldCodeTemplate, 'utf8')), 'utf8');
+}
+function findLegacyProfileDirs(configRoot) {
+    return findConfigDirs(configRoot, (dir) => fs.existsSync(path.join(dir, 'AGENTS-MODS.md')));
+}
+function findProfileDirs(configRoot) {
+    return findConfigDirs(configRoot, (dir) => fs.existsSync(path.join(dir, constants_1.MANIFEST_FILE_NAME)) ||
+        fs.existsSync(path.join(dir, constants_1.LOCAL_TEMPLATE_FILE_NAME)));
+}
+function findConfigDirs(configRoot, matches) {
+    const dirs = [];
+    (0, walk_tree_1.walkTree)(configRoot, (fullPath, entry) => {
+        if (!entry.isDirectory()) {
+            return undefined;
+        }
+        if (matches(fullPath)) {
+            dirs.push(fullPath);
+            return 'skip';
+        }
+        return undefined;
+    }, { shouldPrune: (entry) => entry.isDirectory() && PRUNED_CONFIG_DIRS.has(entry.name) });
+    return dirs.sort();
+}
+function convertLegacyTemplateVars(content) {
+    const replacements = new Map([
+        ['{{AGENT_DIR}}', '{{ agentDir }}'],
+        ['{{AGENTS_MODS_PATH}}', '{{ agentDir }}/AGENTS-MODS.md'],
+        ['{{AGENTS_PATH}}', '{{ agentDir }}/AGENTS.md'],
+        ['{{CLAUDE_PATH}}', '{{ agentDir }}/CLAUDE.md'],
+        ['{{CONFIG_ROOT}}', '{{ configRoot }}'],
+        ['{{PROFILE}}', '{{ profile }}']
+    ]);
+    let converted = content;
+    for (const [from, to] of replacements) {
+        converted = converted.split(from).join(to);
+    }
+    return converted.replace(/^@[^\n]*templates\/AGENTS-CODE\.md[^\n]*\n?/gm, '').replace(/^\n{2,}/, '\n');
+}
+function migrateCodexRuntimeFiles(agentDir) {
+    const runtimeName = /^(?:\.personality_migration|\.tmp|auth\.json|cache|history\.jsonl|installation_id|log|logs|models_cache\.json|sessions|archived_sessions|shell_snapshots|skills|tmp|version\.json)$/;
+    const databaseName = /^(?:logs|state)_.*\.sqlite(?:-.+)?$/;
+    const runtimeNames = fs.readdirSync(agentDir).filter((name) => runtimeName.test(name) || databaseName.test(name));
+    const codexHome = path.join(agentDir, constants_1.LIVE_DIR_NAME, 'memories', 'codex-home');
+    let moved = 0;
+    for (const name of runtimeNames) {
+        const source = path.join(agentDir, name);
+        if (!fs.existsSync(source) && !(0, utils_1.isSymlink)(source)) {
+            continue;
+        }
+        const initialTarget = path.join(codexHome, name);
+        const target = fs.existsSync(initialTarget) || (0, utils_1.isSymlink)(initialTarget) ? (0, utils_1.nextBackupPath)(initialTarget) : initialTarget;
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.renameSync(source, target);
+        moved += 1;
+    }
+    return moved;
+}
+function migrateLooseFiles(agentDir, pattern, targetDirName) {
+    let moved = 0;
+    for (const entry of fs.readdirSync(agentDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !pattern.test(entry.name)) {
+            continue;
+        }
+        const source = path.join(agentDir, entry.name);
+        const targetDir = path.join(agentDir, targetDirName);
+        const target = path.join(targetDir, entry.name);
+        if (fs.existsSync(target)) {
+            continue;
+        }
+        fs.mkdirSync(targetDir, { recursive: true });
+        fs.renameSync(source, target);
+        moved += 1;
+    }
+    return moved;
+}
+function starterConfigRootPath() {
+    return path.resolve(__dirname, '..', 'examples', 'basic-config', 'agent-config');
+}
+function copySkeletonTree(sourceDir, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    const entries = fs.readdirSync(sourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name === 'gitignore' ? '.gitignore' : entry.name);
+        if (entry.isDirectory()) {
+            copySkeletonTree(sourcePath, targetPath);
+        }
+        else if (entry.isFile() && !fs.existsSync(targetPath)) {
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}

package/dist/constants.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_GLOBAL_TEMPLATES = exports.GENERATED_GITIGNORE_ENTRIES = exports.LOCAL_AI_DIRECTORY_NAMES = exports.LOCAL_AI_FILE_NAMES = exports.UNEXPANDED_TEMPLATE_RE = exports.PACKAGE_VERSION = exports.VERBOSE_ENV = exports.CONFIG_DIR_ENV = exports.CONFIG_ROOT_OVERRIDE_ENV = exports.LIVE_DIR_NAME = exports.LOCAL_TEMPLATE_FILE_NAME = exports.MANIFEST_FILE_NAME = exports.CONFIG_ROOT_DEFAULTS_FILE_NAME = exports.IGNORE_FILE_NAME = exports.ENV_FILE_NAME = exports.IS_WINDOWS = void 0;
+exports.IS_WINDOWS = process.platform === 'win32';
+exports.ENV_FILE_NAME = '.agent-run.env';
+exports.IGNORE_FILE_NAME = '.agent-run-ignore';
+exports.CONFIG_ROOT_DEFAULTS_FILE_NAME = 'agent-run.defaults.jsonc';
+exports.MANIFEST_FILE_NAME = 'agent-run.jsonc';
+exports.LOCAL_TEMPLATE_FILE_NAME = 'local.md.njk';
+exports.LIVE_DIR_NAME = 'live';
+exports.CONFIG_ROOT_OVERRIDE_ENV = 'AGENT_RUN_CONFIG_ROOT_OVERRIDE';
+exports.CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
+exports.VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
+exports.PACKAGE_VERSION = '0.99.25';
+exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
+exports.LOCAL_AI_FILE_NAMES = new Set([
+    'AGENTS.md',
+    'AGENTS-MODS.md',
+    'AGENTS.override.md',
+    'CLAUDE.md',
+    'CLAUDE.local.md',
+    '.mcp.json',
+    'codex.md'
+]);
+exports.LOCAL_AI_DIRECTORY_NAMES = new Set(['.agents', '.claude', '.codex']);
+exports.GENERATED_GITIGNORE_ENTRIES = [
+    '# Generated agent-run live profiles',
+    '**/live/',
+    '',
+    '# Optional generated caches',
+    '**/.agent-run-cache/',
+    '',
+    '# Legacy Codex runtime state',
+    '**/auth.json',
+    '**/history.jsonl',
+    '**/sessions/',
+    '**/archived_sessions/',
+    '**/log/',
+    '**/logs/',
+    '**/shell_snapshots/',
+    '**/*.sqlite*',
+    '**/models_cache.json',
+    '**/cache/',
+    '**/.tmp/',
+    '**/installation_id',
+    '**/version.json',
+    '**/.personality_migration',
+    '**/skills/.system/'
+];
+exports.REQUIRED_GLOBAL_TEMPLATES = [
+    'global/agents/code.md.njk',
+    'global/agents/writing.md.njk',
+    'global/snippets/git-rules.md.njk',
+    'global/snippets/no-ai-files.md.njk',
+    'global/snippets/verification.md.njk',
+    'global/tool-templates/codex-config.toml.njk',
+    'global/tool-templates/claude-settings.json.njk',
+    'global/skills/commit-workflow/SKILL.md.njk',
+    'global/skills/github-release/SKILL.md.njk',
+    'global/skills/release-package-check/SKILL.md.njk',
+    'global/skills/code-review-organizer/SKILL.md.njk'
+];