@technomoron/agent-run 0.99.24 → 0.99.26

package/dist/manifest.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProfileConfigured = isProfileConfigured;
+exports.createProfileMarker = createProfileMarker;
+exports.ensureRootDefaultsFile = ensureRootDefaultsFile;
+exports.createDefaultLocalFile = createDefaultLocalFile;
+exports.convertLegacyProfileIfNeeded = convertLegacyProfileIfNeeded;
+exports.loadManifest = loadManifest;
+exports.normalizeManifest = normalizeManifest;
+const fs = require("fs");
+const path = require("path");
+const jsonc_parser_1 = require("jsonc-parser");
+const constants_1 = require("./constants");
+const defaults_1 = require("./defaults");
+const utils_1 = require("./utils");
+function isProfileConfigured(agentDir) {
+    return [constants_1.MANIFEST_FILE_NAME, constants_1.LOCAL_TEMPLATE_FILE_NAME, 'AGENTS-MODS.md'].some((name) => fs.existsSync(path.join(agentDir, name)));
+}
+function createProfileMarker(agentDir) {
+    const manifestPath = path.join(agentDir, constants_1.MANIFEST_FILE_NAME);
+    if (fs.existsSync(manifestPath)) {
+        return;
+    }
+    fs.mkdirSync(agentDir, { recursive: true });
+    fs.writeFileSync(manifestPath, '{}\n', 'utf8');
+    (0, utils_1.verbose)(`created ${manifestPath}`);
+}
+function ensureRootDefaultsFile(configRoot) {
+    const defaultsPath = path.join(configRoot, constants_1.CONFIG_ROOT_DEFAULTS_FILE_NAME);
+    if (fs.existsSync(defaultsPath)) {
+        return;
+    }
+    fs.mkdirSync(configRoot, { recursive: true });
+    fs.writeFileSync(defaultsPath, (0, defaults_1.stringifyRootDefaults)(), 'utf8');
+    (0, utils_1.verbose)(`created ${defaultsPath}`);
+}
+function createDefaultLocalFile(agentDir) {
+    const localPath = path.join(agentDir, constants_1.LOCAL_TEMPLATE_FILE_NAME);
+    if (fs.existsSync(localPath)) {
+        return localPath;
+    }
+    const legacyPath = path.join(agentDir, 'AGENTS-MODS.md');
+    const content = fs.existsSync(legacyPath) ? fs.readFileSync(legacyPath, 'utf8') : (0, defaults_1.defaultLocalTemplate)();
+    fs.mkdirSync(agentDir, { recursive: true });
+    fs.writeFileSync(localPath, content, 'utf8');
+    (0, utils_1.verbose)(`created ${localPath}`);
+    return localPath;
+}
+function convertLegacyProfileIfNeeded(agentDir) {
+    const legacyPath = path.join(agentDir, 'AGENTS-MODS.md');
+    const localPath = path.join(agentDir, constants_1.LOCAL_TEMPLATE_FILE_NAME);
+    if (fs.existsSync(legacyPath) && !fs.existsSync(localPath)) {
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.writeFileSync(localPath, fs.readFileSync(legacyPath, 'utf8'), 'utf8');
+        (0, utils_1.verbose)(`converted ${legacyPath} -> ${localPath}`);
+    }
+}
+function loadManifest(configRoot, agentDir, profile, trace) {
+    const rootDefaultsPath = path.join(configRoot, constants_1.CONFIG_ROOT_DEFAULTS_FILE_NAME);
+    const profileManifestPath = path.join(agentDir, constants_1.MANIFEST_FILE_NAME);
+    const rootDefaults = fs.existsSync(rootDefaultsPath) ? parseManifestFile(rootDefaultsPath, trace) : {};
+    if (rootDefaults.profile !== undefined) {
+        throw new Error(`${rootDefaultsPath} must not set profile; profiles are inferred from project mapping`);
+    }
+    let profileManifest = fs.existsSync(profileManifestPath) ? parseManifestFile(profileManifestPath, trace) : {};
+    if (!fs.existsSync(profileManifestPath)) {
+        profileManifest = applyLegacyIncludeFallback(agentDir, profileManifest);
+    }
+    const builtIn = (0, defaults_1.defaultManifest)(profile);
+    const mergedDefaults = mergeManifest(builtIn, rootDefaults, false);
+    return mergeManifest(mergedDefaults, profileManifest, true, profile);
+}
+function parseManifestFile(filePath, trace) {
+    trace?.sourceFiles.add(filePath);
+    const text = fs.readFileSync(filePath, 'utf8');
+    const errors = [];
+    const parsed = (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true });
+    if (errors.length > 0) {
+        const first = errors[0];
+        const detail = first ? `${(0, jsonc_parser_1.printParseErrorCode)(first.error)} at offset ${first.offset}` : 'unknown JSONC parse error';
+        throw new Error(`invalid JSONC in ${filePath}: ${detail}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`manifest must be an object: ${filePath}`);
+    }
+    return parsed;
+}
+function applyLegacyIncludeFallback(agentDir, manifest) {
+    const localPath = path.join(agentDir, constants_1.LOCAL_TEMPLATE_FILE_NAME);
+    const legacyPath = path.join(agentDir, 'AGENTS-MODS.md');
+    if (!fs.existsSync(localPath) && fs.existsSync(legacyPath)) {
+        return { ...manifest, agent: { ...manifest.agent, includes: ['{{ profile }}/AGENTS-MODS.md'] } };
+    }
+    return manifest;
+}
+function mergeManifest(base, override, allowProfile, inferredProfile) {
+    const merged = {
+        ...base,
+        ...override,
+        agent: { ...base.agent, ...override.agent },
+        skills: mergeSkills(base.skills, override.skills),
+        tools: { ...base.tools, ...override.tools },
+        guardrails: { ...base.guardrails, ...override.guardrails },
+        paths: { ...base.paths, ...override.paths }
+    };
+    if (!allowProfile) {
+        merged.profile = base.profile;
+    }
+    else {
+        merged.profile = override.profile ?? inferredProfile ?? base.profile;
+    }
+    return merged;
+}
+function mergeSkills(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (Array.isArray(override)) {
+        return [...override];
+    }
+    const baseObject = asSkillObject(base);
+    return {
+        install: override.install ?? baseObject.install,
+        overrides: { ...baseObject.overrides, ...override.overrides }
+    };
+}
+function asSkillObject(skills) {
+    if (Array.isArray(skills)) {
+        return { install: skills, overrides: {} };
+    }
+    return {
+        install: skills?.install ?? [],
+        overrides: skills?.overrides ?? {}
+    };
+}
+function normalizeManifest(manifest, profile) {
+    const fallback = (0, defaults_1.defaultManifest)(profile);
+    const skills = asSkillObject(manifest.skills ?? fallback.skills);
+    const fallbackPaths = fallback.paths ?? {};
+    const paths = manifest.paths ?? {};
+    return {
+        profile: manifest.profile ?? profile,
+        kind: manifest.kind ?? fallback.kind ?? 'code',
+        agent: {
+            base: manifest.agent?.base ?? fallback.agent?.base ?? 'global/agents/code.md.njk',
+            includes: manifest.agent?.includes ?? [`{{ profile }}/${constants_1.LOCAL_TEMPLATE_FILE_NAME}`]
+        },
+        skills: {
+            install: normalizeInstalledSkills(skills.install),
+            overrides: skills.overrides
+        },
+        tools: {
+            codex: manifest.tools?.codex ?? true,
+            claude: manifest.tools?.claude ?? true
+        },
+        checks: manifest.checks ?? fallback.checks ?? [],
+        guardrails: {
+            blockGitWrite: manifest.guardrails?.blockGitWrite ?? true,
+            blockPublish: manifest.guardrails?.blockPublish ?? true,
+            blockGithubRelease: manifest.guardrails?.blockGithubRelease ?? true,
+            forbidRepoAiFiles: manifest.guardrails?.forbidRepoAiFiles ?? true
+        },
+        paths: {
+            changesFile: paths.changesFile ?? fallbackPaths.changesFile ?? '{{ projectRoot }}/CHANGES',
+            reviewDir: normalizeLegacyReviewPath(paths.reviewDir ?? fallbackPaths.reviewDir ?? '{{ profileDir }}/reviews'),
+            reviewFile: normalizeLegacyReviewPath(paths.reviewFile ?? fallbackPaths.reviewFile ?? '{{ profileDir }}/reviews/REVIEW-{{ date }}.md'),
+            reviewConsolidatedFile: paths.reviewConsolidatedFile ?? fallbackPaths.reviewConsolidatedFile,
+            memoriesDir: paths.memoriesDir ?? fallbackPaths.memoriesDir ?? '{{ agentDir }}/memories'
+        }
+    };
+}
+function normalizeInstalledSkills(names) {
+    return [...new Set(names.map(normalizeSkillName))];
+}
+function normalizeSkillName(name) {
+    const normalized = name === 'code-review' ? 'code-review-organizer' : name;
+    if (!/^[A-Za-z0-9._-]+$/.test(normalized)) {
+        throw new Error(`invalid skill name: ${name}`);
+    }
+    return normalized;
+}
+function normalizeLegacyReviewPath(value) {
+    if (value === '{{ agentDir }}/reviews') {
+        return '{{ profileDir }}/reviews';
+    }
+    if (value === '{{ agentDir }}/reviews/REVIEW-{{ date }}.md') {
+        return '{{ profileDir }}/reviews/REVIEW-{{ date }}.md';
+    }
+    return value;
+}

package/dist/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/process.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRealBinary = findRealBinary;
+exports.execTool = execTool;
+exports.execCommand = execCommand;
+exports.openEditor = openEditor;
+exports.parseEditorCommand = parseEditorCommand;
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const crossSpawn = require('cross-spawn');
+function findRealBinary(tool) {
+    const pathDirs = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+    const currentScriptArg = process.argv[1];
+    const currentScript = currentScriptArg ? fs.realpathSync(currentScriptArg) : '';
+    const wrappers = wrapperCandidates(tool);
+    for (const dir of pathDirs) {
+        for (const extension of (0, utils_1.getExecutableExtensions)(tool)) {
+            const candidate = path.join(dir, `${tool}${extension}`);
+            if (!fs.existsSync(candidate) || !(0, utils_1.isExecutable)(candidate)) {
+                continue;
+            }
+            const resolvedCandidate = safeRealpath(candidate);
+            if (resolvedCandidate === currentScript || wrappers.has(resolvedCandidate)) {
+                continue;
+            }
+            if (isAgentRunRedirectShim(candidate)) {
+                (0, utils_1.verbose)(`skip ${tool} redirect shim: ${candidate}`);
+                continue;
+            }
+            return candidate;
+        }
+    }
+    (0, utils_1.fail)(`no ${tool} binary found in PATH`);
+}
+function wrapperCandidates(tool) {
+    const names = [
+        tool,
+        `${tool}.js`,
+        `${tool}.cmd`,
+        `${tool}.bat`,
+        `${tool}.exe`,
+        'agent-run',
+        'agent-run.js',
+        'agent-run.cmd',
+        'agent-run.bat',
+        'agent-run.exe'
+    ];
+    return new Set(names.map((name) => path.join(__dirname, name)).filter(fs.existsSync).map(safeRealpath));
+}
+function safeRealpath(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch {
+        return filePath;
+    }
+}
+function isAgentRunRedirectShim(filePath) {
+    try {
+        const handle = fs.openSync(filePath, 'r');
+        try {
+            const buffer = Buffer.alloc(4096);
+            const bytesRead = fs.readSync(handle, buffer, 0, buffer.length, 0);
+            return buffer.subarray(0, bytesRead).toString('utf8').includes('Run agent-run instead');
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function execTool(command, args) {
+    (0, utils_1.verbose)(`exec tool: ${(0, utils_1.formatCommand)(command, args)}`);
+    execCommand(command, args);
+}
+function execCommand(command, args, env, cwd, onExit) {
+    (0, utils_1.verbose)(`spawn: ${(0, utils_1.formatCommand)(command, args)} cwd=${cwd ?? process.cwd()}`);
+    const child = crossSpawn(command, args, { cwd, env, stdio: 'inherit' });
+    child.on('exit', (code, signal) => {
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        const originalCode = code === null ? 1 : code;
+        process.exit(onExit ? onExit(originalCode) : originalCode);
+    });
+    child.on('error', (error) => (0, utils_1.fail)(error.message));
+}
+function openEditor(filePath) {
+    const configuredEditor = process.env.VISUAL?.trim() || process.env.EDITOR?.trim();
+    if (configuredEditor) {
+        runConfiguredEditor(configuredEditor, filePath);
+        return;
+    }
+    const vscodeCommand = findVsCodeEditorCommand();
+    if (vscodeCommand !== null) {
+        execCommand(vscodeCommand, ['--reuse-window', filePath]);
+        return;
+    }
+    const fallbackEditor = findFallbackEditor();
+    if (fallbackEditor !== null) {
+        execCommand(fallbackEditor, [filePath]);
+        return;
+    }
+    if (constants_1.IS_WINDOWS) {
+        execCommand('explorer.exe', [filePath]);
+    }
+    else if (process.platform === 'darwin') {
+        execCommand('open', [filePath]);
+    }
+    else {
+        execCommand('xdg-open', [filePath]);
+    }
+}
+function runConfiguredEditor(commandLine, filePath) {
+    let editorArgs;
+    try {
+        editorArgs = parseEditorCommand(commandLine);
+    }
+    catch (error) {
+        (0, utils_1.fail)(`invalid editor command: ${(0, utils_1.formatError)(error)}`);
+    }
+    const [command, ...args] = editorArgs;
+    if (!command) {
+        (0, utils_1.fail)('invalid editor command: command is empty');
+    }
+    execCommand(command, [...args, filePath]);
+}
+function parseEditorCommand(commandLine) {
+    const args = [];
+    let current = '';
+    let quote = null;
+    let tokenStarted = false;
+    for (let index = 0; index < commandLine.length; index += 1) {
+        const character = commandLine[index] ?? '';
+        if (quote !== null) {
+            if (character === quote) {
+                quote = null;
+                continue;
+            }
+            if (character === '\\' && quote === '"') {
+                const next = commandLine[index + 1];
+                if (next === '"' || next === '\\') {
+                    current += next;
+                    index += 1;
+                    continue;
+                }
+            }
+            current += character;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            tokenStarted = true;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (tokenStarted) {
+                args.push(current);
+                current = '';
+                tokenStarted = false;
+            }
+            continue;
+        }
+        if (character === '\\') {
+            const next = commandLine[index + 1];
+            if (next !== undefined && (/\s/.test(next) || next === "'" || next === '"' || next === '\\')) {
+                current += next;
+                index += 1;
+                tokenStarted = true;
+                continue;
+            }
+        }
+        current += character;
+        tokenStarted = true;
+    }
+    if (quote !== null) {
+        throw new Error(`unterminated ${quote} quote`);
+    }
+    if (tokenStarted) {
+        args.push(current);
+    }
+    if (args.length === 0) {
+        throw new Error('command is empty');
+    }
+    return args;
+}
+function findVsCodeEditorCommand() {
+    if (!isRunningInVsCodeTerminal()) {
+        return null;
+    }
+    return ['code', 'codium'].map(utils_1.findExecutable).find((command) => command !== null) ?? null;
+}
+function isRunningInVsCodeTerminal() {
+    const termProgram = process.env.TERM_PROGRAM?.trim().toLowerCase();
+    return (termProgram === 'vscode' ||
+        Boolean(process.env.VSCODE_GIT_IPC_HANDLE) ||
+        Boolean(process.env.VSCODE_IPC_HOOK) ||
+        Boolean(process.env.VSCODE_IPC_HOOK_CLI));
+}
+function findFallbackEditor() {
+    const candidates = constants_1.IS_WINDOWS ? ['notepad.exe'] : ['joe', 'sensible-editor', 'editor', 'nano', 'nvim', 'vim', 'vi'];
+    return candidates.map(utils_1.findExecutable).find((command) => command !== null) ?? null;
+}