@aopslabs/aops 0.2.0

package/dist/utils/agents-md.js

@@ -0,0 +1,281 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { AOPS_AGENTS_MD_TEMPLATE_SEEDS, DISCUSS_AGENTS_MD_TEMPLATE_SLUG, DEFAULT_AGENTS_MD_TEMPLATE_SLUG, } from '../seeds/agents-md.js';
+import { findWorkspaceRoot } from './workspace-root.js';
+export const AGENTS_MD_MANAGED_BEGIN = '<!-- aops:agents-md-templates BEGIN version=1 managed-by=aops-cli -->';
+export const AGENTS_MD_MANAGED_END = '<!-- aops:agents-md-templates END -->';
+function normalizeBoolean(value) {
+    return value === true;
+}
+function uniqueSeeds(seeds) {
+    const seen = new Set();
+    return seeds.filter((seed) => {
+        if (seen.has(seed.slug))
+            return false;
+        seen.add(seed.slug);
+        return true;
+    });
+}
+export function selectAgentsMdTemplates(options = {}) {
+    const all = normalizeBoolean(options.all);
+    const noDefaultTask = normalizeBoolean(options.noDefaultTask);
+    const discuss = normalizeBoolean(options.discuss);
+    let selected = all ? [...AOPS_AGENTS_MD_TEMPLATE_SEEDS] : [];
+    if (!all && !noDefaultTask) {
+        const seed = AOPS_AGENTS_MD_TEMPLATE_SEEDS.find((entry) => entry.slug === DEFAULT_AGENTS_MD_TEMPLATE_SLUG);
+        if (seed)
+            selected.push(seed);
+    }
+    if (discuss) {
+        const seed = AOPS_AGENTS_MD_TEMPLATE_SEEDS.find((entry) => entry.slug === DISCUSS_AGENTS_MD_TEMPLATE_SLUG);
+        if (seed)
+            selected.push(seed);
+    }
+    if (noDefaultTask) {
+        selected = selected.filter((entry) => entry.slug !== DEFAULT_AGENTS_MD_TEMPLATE_SLUG);
+    }
+    selected = uniqueSeeds(selected);
+    if (selected.length === 0) {
+        throw new Error('No AGENTS.md prompt templates selected. Drop --no-default-task or add --discuss/--all.');
+    }
+    return selected;
+}
+export function resolveAgentsMdTarget(root) {
+    const startDir = process.cwd();
+    const rootDir = root ? path.resolve(startDir, root) : findWorkspaceRoot(startDir);
+    return {
+        rootDir,
+        filePath: path.join(rootDir, 'AGENTS.md'),
+    };
+}
+function findInitSectionEnd(content) {
+    const match = content.match(/^#\s*INIT\b.*$/im);
+    if (!match || match.index === undefined)
+        return undefined;
+    const afterInitHeader = match.index + match[0].length;
+    const rest = content.slice(afterInitHeader);
+    const nextTopLevelHeader = rest.match(/^\s*#(?!\s*INIT\b)/m);
+    if (!nextTopLevelHeader || nextTopLevelHeader.index === undefined)
+        return content.length;
+    return afterInitHeader + nextTopLevelHeader.index;
+}
+function managedBlockPattern() {
+    const begin = AGENTS_MD_MANAGED_BEGIN.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const end = AGENTS_MD_MANAGED_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\n*${begin}[\\s\\S]*?${end}\\n*`, 'm');
+}
+export function removeAgentsMdManagedBlock(content) {
+    const pattern = managedBlockPattern();
+    if (!pattern.test(content))
+        return { content, changed: false };
+    const next = content.replace(pattern, '\n\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+    return { content: `${next}\n`, changed: true };
+}
+export function mergeAgentsMdManagedBlock(content, block) {
+    const normalizedBlock = `${block.trimEnd()}\n`;
+    const pattern = managedBlockPattern();
+    let next;
+    if (pattern.test(content)) {
+        next = content.replace(pattern, `\n\n${normalizedBlock}\n`);
+    }
+    else if (content.trim().length === 0) {
+        next = `${normalizedBlock}\n`;
+    }
+    else {
+        const insertAt = findInitSectionEnd(content);
+        if (insertAt !== undefined) {
+            const prefix = content.slice(0, insertAt).trimEnd();
+            const suffix = content.slice(insertAt).trimStart();
+            next = `${prefix}\n\n${normalizedBlock}\n${suffix}`;
+        }
+        else {
+            next = `${normalizedBlock}\n${content.replace(/^\uFEFF/, '').trimStart()}`;
+        }
+    }
+    next = `${next.trimEnd()}\n`;
+    return { content: next, changed: next !== content };
+}
+function promptMirrorPath(rootDir, seed) {
+    return path.join(rootDir, ...seed.mirrorPath.split('/'));
+}
+async function readPromptBody(rootDir, seed) {
+    const filePath = promptMirrorPath(rootDir, seed);
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        return raw.trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function markdownFenceFor(content) {
+    let fence = '~~~';
+    while (content.includes(fence)) {
+        fence += '~';
+    }
+    return fence;
+}
+async function renderEmbeddedPrompt(rootDir, seed) {
+    const body = (await readPromptBody(rootDir, seed)) ?? seed.snippet.map((line) => `- ${line}`).join('\n');
+    const fence = markdownFenceFor(body);
+    return [
+        `<details><summary>${seed.title} body</summary>`,
+        '',
+        `${fence}markdown`,
+        body,
+        fence,
+        '',
+        '</details>',
+    ];
+}
+export async function buildAgentsMdManagedBlock(rootDir, selectedTemplates, options = {}) {
+    const warnings = [];
+    const lines = [
+        AGENTS_MD_MANAGED_BEGIN,
+        '## AOPS Prompt Template Bootstrap',
+        '',
+        'This managed block is generated by `aops-cli agents-md update`.',
+        'Keep project-specific agent rules outside this block.',
+        '',
+        'Refresh hosted prompt mirrors when needed:',
+        '',
+        '```bash',
+        'aops-cli sync pull --apply --hosted-project-slug aops --json',
+        '```',
+        '',
+        'Use `aops-cli agents-md preview --discuss` before adding the standalone discuss / decision-ritual guidance.',
+        'Use `aops-cli agents-md update --discuss --apply` to inject it.',
+        '',
+        'Selected templates:',
+        '',
+    ];
+    for (const seed of selectedTemplates) {
+        lines.push(`### ${seed.title}`);
+        lines.push('');
+        lines.push(`- Slug: \`${seed.slug}\``);
+        lines.push(`- Ref: \`${seed.promptRef}\``);
+        lines.push(`- Mirror: \`${seed.mirrorPath}\``);
+        lines.push(`- Purpose: ${seed.description}`);
+        lines.push('- Runtime reminder:');
+        seed.snippet.forEach((entry) => lines.push(`  - ${entry}`));
+        lines.push('');
+        if (options.embedPrompts === true) {
+            const embedded = await renderEmbeddedPrompt(rootDir, seed);
+            lines.push(...embedded, '');
+        }
+    }
+    if (options.embedPrompts === true) {
+        warnings.push('Embedded prompt bodies can make AGENTS.md large; prefer mirrors unless offline bootstrap requires embedding.');
+    }
+    else {
+        lines.push('Prompt bodies stay in hosted mirrors by default. Use `--embed-prompts` only for explicit offline bootstrap needs.');
+        lines.push('');
+    }
+    lines.push(AGENTS_MD_MANAGED_END);
+    return {
+        block: `${lines.join('\n').trimEnd()}\n`,
+        warnings,
+    };
+}
+async function readAgentsFile(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT')
+            return '';
+        throw error;
+    }
+}
+function resolveCliInvocation() {
+    if (process.env.AOPS_CLI_BIN)
+        return { command: process.env.AOPS_CLI_BIN, argsPrefix: [] };
+    const entrypoint = process.argv[1];
+    if (entrypoint && entrypoint.endsWith('.js')) {
+        return { command: process.execPath, argsPrefix: [entrypoint] };
+    }
+    return { command: 'aops-cli', argsPrefix: [] };
+}
+async function runHostedSync(rootDir) {
+    const cli = resolveCliInvocation();
+    const args = ['sync', 'pull', '--apply', '--hosted-project-slug', 'aops', '--json'];
+    const spawnArgs = [...cli.argsPrefix, ...args];
+    return await new Promise((resolve, reject) => {
+        const child = spawn(cli.command, spawnArgs, {
+            cwd: rootDir,
+            shell: process.platform === 'win32',
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            const command = [cli.command, ...spawnArgs].join(' ');
+            if (code === 0) {
+                resolve({ command, stdout: stdout.trim(), stderr: stderr.trim() });
+                return;
+            }
+            reject(new Error(`${command} failed with exit code ${code}: ${stderr.trim() || stdout.trim()}`));
+        });
+    });
+}
+export async function updateAgentsMdFile(options = {}) {
+    if (options.apply !== true && options.preview !== true) {
+        throw new Error('This command updates AGENTS.md. Retry with --apply or use --preview.');
+    }
+    if (options.preview === true && options.syncHosted === true) {
+        throw new Error('--sync-hosted mutates .aops/hosted mirrors. Use `aops-cli agents-md update --sync-hosted --apply`.');
+    }
+    const target = resolveAgentsMdTarget(options.root);
+    const selectedTemplates = selectAgentsMdTemplates(options);
+    const syncHosted = options.syncHosted === true ? await runHostedSync(target.rootDir) : undefined;
+    const { block, warnings } = await buildAgentsMdManagedBlock(target.rootDir, selectedTemplates, {
+        embedPrompts: options.embedPrompts,
+    });
+    const current = await readAgentsFile(target.filePath);
+    const merged = mergeAgentsMdManagedBlock(current, block);
+    if (options.apply === true) {
+        await fs.mkdir(path.dirname(target.filePath), { recursive: true });
+        await fs.writeFile(target.filePath, merged.content, 'utf-8');
+    }
+    return {
+        action: 'update',
+        ...target,
+        changed: merged.changed,
+        selectedTemplates,
+        block,
+        content: options.preview === true ? merged.content : undefined,
+        warnings,
+        syncHosted,
+    };
+}
+export async function resetAgentsMdFile(options = {}) {
+    if (options.preview !== true && !(options.apply === true && options.confirm === true)) {
+        throw new Error('This command removes the managed AGENTS.md block. Retry with --apply --confirm or use --preview.');
+    }
+    const target = resolveAgentsMdTarget(options.root);
+    const current = existsSync(target.filePath) ? await readAgentsFile(target.filePath) : '';
+    const removed = removeAgentsMdManagedBlock(current);
+    if (options.apply === true && options.confirm === true && removed.changed) {
+        await fs.writeFile(target.filePath, removed.content, 'utf-8');
+    }
+    return {
+        action: 'reset',
+        ...target,
+        changed: removed.changed,
+        content: options.preview === true ? removed.content : undefined,
+        warnings: [],
+    };
+}

package/dist/utils/api.js

@@ -0,0 +1,255 @@
+import { createAopsApiClient } from '@aopslabs/api-client';
+import { ensureApiTokensLoaded, findApiTargetByBaseUrl, findApiTargetByBaseUrlReadOnly, getActiveApiTarget, getActiveApiTargetReadOnly, getApiTarget, getApiTargetReadOnly, getCachedApiTokens, normalizeApiTargetBaseUrl, readApiTokensFromConfigFile, readApiTokensFromConfigFileReadOnly, setApiTokensInConfig, validateApiTarget, } from './config.js';
+import { createRefreshRaceRecovery } from './refresh-race.js';
+function normalizeNonEmpty(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveAccessToken(input, allowEnvironment = true) {
+    return (normalizeNonEmpty(input) ??
+        (allowEnvironment ? normalizeNonEmpty(process.env.AOPS_API_ACCESS_TOKEN) : undefined) ??
+        (allowEnvironment ? normalizeNonEmpty(process.env.AOPS_API_TOKEN) : undefined));
+}
+function resolveRefreshToken(input, allowEnvironment = true) {
+    return normalizeNonEmpty(input) ??
+        (allowEnvironment ? normalizeNonEmpty(process.env.AOPS_API_REFRESH_TOKEN) : undefined);
+}
+function resolveDefaultTimeoutMs() {
+    const raw = normalizeNonEmpty(process.env.AOPS_API_TIMEOUT_MS);
+    if (!raw)
+        return 15_000;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 15_000;
+    return parsed;
+}
+export function resolveCliApiTarget(input, targetName) {
+    const explicit = normalizeNonEmpty(input);
+    const selectedTarget = normalizeNonEmpty(targetName);
+    if (selectedTarget) {
+        const target = getApiTarget(selectedTarget);
+        if (!target)
+            throw new Error(`aops_target_not_found:${selectedTarget}`);
+        if (explicit && normalizeApiTargetBaseUrl(explicit) !== target.apiBaseUrl) {
+            throw new Error('aops_target_api_base_url_mismatch');
+        }
+        return { baseUrl: target.apiBaseUrl, targetName: target.name, endpointSource: 'target' };
+    }
+    if (explicit) {
+        const baseUrl = validateApiTarget({ apiBaseUrl: explicit }).apiBaseUrl;
+        return {
+            baseUrl,
+            targetName: findApiTargetByBaseUrl(baseUrl)?.name,
+            endpointSource: 'option',
+        };
+    }
+    const env = normalizeNonEmpty(process.env.AOPS_API_BASE_URL) ?? normalizeNonEmpty(process.env.AOPS_API_SERVER);
+    if (env) {
+        const baseUrl = validateApiTarget({ apiBaseUrl: env }).apiBaseUrl;
+        return {
+            baseUrl,
+            targetName: findApiTargetByBaseUrl(baseUrl)?.name,
+            endpointSource: 'environment',
+        };
+    }
+    const activeTarget = getActiveApiTarget();
+    if (activeTarget) {
+        return {
+            baseUrl: activeTarget.apiBaseUrl,
+            targetName: activeTarget.name,
+            endpointSource: 'target',
+        };
+    }
+    return { baseUrl: validateApiTarget({ apiBaseUrl: 'http://localhost:5900' }).apiBaseUrl, endpointSource: 'default' };
+}
+function resolveCliApiTargetReadOnly(input, targetName) {
+    const explicit = normalizeNonEmpty(input);
+    const selectedTarget = normalizeNonEmpty(targetName);
+    if (selectedTarget) {
+        const target = getApiTargetReadOnly(selectedTarget);
+        if (!target)
+            throw new Error(`aops_target_not_found:${selectedTarget}`);
+        if (explicit && normalizeApiTargetBaseUrl(explicit) !== target.apiBaseUrl) {
+            throw new Error('aops_target_api_base_url_mismatch');
+        }
+        return { baseUrl: target.apiBaseUrl, targetName: target.name, endpointSource: 'target' };
+    }
+    if (explicit) {
+        const baseUrl = validateApiTarget({ apiBaseUrl: explicit }).apiBaseUrl;
+        return {
+            baseUrl,
+            targetName: findApiTargetByBaseUrlReadOnly(baseUrl)?.name,
+            endpointSource: 'option',
+        };
+    }
+    const env = normalizeNonEmpty(process.env.AOPS_API_BASE_URL) ?? normalizeNonEmpty(process.env.AOPS_API_SERVER);
+    if (env) {
+        const baseUrl = validateApiTarget({ apiBaseUrl: env }).apiBaseUrl;
+        return {
+            baseUrl,
+            targetName: findApiTargetByBaseUrlReadOnly(baseUrl)?.name,
+            endpointSource: 'environment',
+        };
+    }
+    const activeTarget = getActiveApiTargetReadOnly();
+    if (activeTarget) {
+        return {
+            baseUrl: activeTarget.apiBaseUrl,
+            targetName: activeTarget.name,
+            endpointSource: 'target',
+        };
+    }
+    return { baseUrl: validateApiTarget({ apiBaseUrl: 'http://localhost:5900' }).apiBaseUrl, endpointSource: 'default' };
+}
+export function resolveCliApiBaseUrl(input, targetName) {
+    return resolveCliApiTarget(input, targetName).baseUrl;
+}
+export async function createCliApiClient(options = {}) {
+    const resolution = options.readOnly
+        ? resolveCliApiTargetReadOnly(options.apiBaseUrl, options.targetName)
+        : resolveCliApiTarget(options.apiBaseUrl, options.targetName);
+    if (!options.readOnly)
+        await ensureApiTokensLoaded(resolution.targetName);
+    const baseUrl = resolution.baseUrl;
+    const cached = resolution.targetName
+        ? options.readOnly
+            ? await readApiTokensFromConfigFileReadOnly(resolution.targetName)
+            : getCachedApiTokens(resolution.targetName)
+        : {};
+    const allowEnvironmentTokens = resolution.targetName === undefined;
+    let accessToken = resolveAccessToken(options.accessToken, allowEnvironmentTokens) ?? cached.accessToken;
+    let refreshToken = options.readOnly
+        ? undefined
+        : resolveRefreshToken(options.refreshToken, allowEnvironmentTokens) ?? cached.refreshToken;
+    let credentialRevision = cached.credentialRevision;
+    const client = createAopsApiClient({
+        baseUrl,
+        defaultTimeoutMs: options.timeoutMs ?? resolveDefaultTimeoutMs(),
+        getAccessToken: () => accessToken,
+        getRefreshToken: () => refreshToken,
+        onTokenRefresh: options.readOnly ? undefined : async ({ accessToken: nextAccess, refreshToken: nextRefresh, userId }) => {
+            const expectedCredentialRevision = credentialRevision;
+            accessToken = nextAccess;
+            refreshToken = nextRefresh;
+            if (resolution.targetName) {
+                credentialRevision = await setApiTokensInConfig({
+                    accessToken: nextAccess,
+                    refreshToken: nextRefresh,
+                    userId,
+                    apiServer: baseUrl,
+                    targetName: resolution.targetName,
+                    expectedCredentialRevision,
+                });
+            }
+            await options.onTokenRefresh?.({ accessToken: nextAccess, refreshToken: nextRefresh, userId });
+        },
+        onRefreshRace: !options.readOnly && resolution.targetName ? createRefreshRaceRecovery({
+            getCurrentRefreshToken: () => refreshToken,
+            readLatestTokens: async () => {
+                const latest = await readApiTokensFromConfigFile(resolution.targetName);
+                if (latest.accessToken && latest.refreshToken) {
+                    credentialRevision = latest.credentialRevision;
+                    return { accessToken: latest.accessToken, refreshToken: latest.refreshToken, userId: latest.userId };
+                }
+                return null;
+            },
+            applyTokens: ({ accessToken: nextAccess, refreshToken: nextRefresh }) => {
+                accessToken = nextAccess;
+                refreshToken = nextRefresh;
+            },
+        }) : async () => false,
+    });
+    return {
+        client,
+        baseUrl,
+        targetName: resolution.targetName,
+        endpointSource: resolution.endpointSource,
+        getAccessToken: () => accessToken,
+        getRefreshToken: () => refreshToken,
+    };
+}
+function normalizeAuthProvider(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === 'trusted-local' || trimmed === 'trusted_local' || trimmed === 'trusted') {
+        return 'trusted-local';
+    }
+    if (trimmed === 'authv2-jwt-session' ||
+        trimmed === 'remote-session' ||
+        trimmed === 'remote_session' ||
+        trimmed === 'authv2_jwt_session' ||
+        trimmed === 'jwt-session' ||
+        trimmed === 'jwt_session' ||
+        trimmed === 'session') {
+        return 'remote-session';
+    }
+    return undefined;
+}
+export async function probeCliRuntimeMode(apiState, options = {}) {
+    try {
+        const response = await apiState.client.requestXfJson('/api/auth/me', { method: 'GET' }, { auth: false, retry401: false, timeoutMs: options.timeoutMs });
+        const authProvider = normalizeAuthProvider(response.result?.data?.authProvider) ??
+            (response.status === 401 ? 'remote-session' : undefined) ??
+            'remote-session';
+        const authRequired = typeof response.result?.data?.authRequired === 'boolean'
+            ? response.result.data.authRequired
+            : authProvider === 'remote-session';
+        const principalUserId = normalizeNonEmpty(response.result?.data?.principal?.userId);
+        return {
+            authProvider,
+            authRequired,
+            hasPrincipal: response.status === 200 && response.result?.ok === true && Boolean(principalUserId),
+            principalUserId,
+        };
+    }
+    catch {
+        return {
+            authProvider: 'remote-session',
+            authRequired: true,
+            hasPrincipal: false,
+        };
+    }
+}
+export function buildCliApiClientOptions(options = {}) {
+    return {
+        apiBaseUrl: options.apiBaseUrl,
+        targetName: options.targetName,
+        accessToken: options.accessToken,
+        refreshToken: options.refreshToken,
+        timeoutMs: options.timeoutMs,
+        readOnly: options.readOnly,
+    };
+}
+export async function createCliApiClientFromOptions(options = {}) {
+    return createCliApiClient(buildCliApiClientOptions(options));
+}
+export async function fetchCliPublicJson(apiState, path, options = {}) {
+    return apiState.client.fetchJson(path, {
+        method: 'GET',
+        auth: false,
+        retry401: false,
+        timeoutMs: options.timeoutMs,
+    });
+}
+export async function fetchCliHealth(apiState, options = {}) {
+    return fetchCliPublicJson(apiState, '/api/health', options);
+}
+export async function fetchCliBootstrapHealth(apiState, options = {}) {
+    const payload = await fetchCliHealth(apiState, options);
+    return (payload?.data?.bootstrap ?? {});
+}
+export async function isCliAuthRequired(apiState, options = {}) {
+    return (await probeCliRuntimeMode(apiState, { timeoutMs: options.timeoutMs })).authRequired;
+}
+export async function isCliHostReachable(apiState, options = {}) {
+    try {
+        await fetchCliHealth(apiState, options);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}