@waron97/prbot 2.6.1 → 3.0.0

package/src/agrippa/commands/pull.js

@@ -0,0 +1,221 @@
+import inquirer from 'inquirer';
+import { dirname } from 'path';
+import { readConfig, writeConfig, loadEffectiveEnv } from '../lib/config.js';
+import { getPhasesByIds, getPhasesByWorkflow, listMfas } from '../lib/api.js';
+import { getToken } from '../../lib/auth.js';
+import { computeChecksum } from '../lib/checksum.js';
+import { readCodeFile, writeCodeFile, fileExists, toSlug } from '../lib/workspace.js';
+
+async function pull() {
+    const config = readConfig();
+    loadEffectiveEnv(config);
+
+    const ripUrl = process.env.RIP_URL;
+    if (!ripUrl) throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+
+    // Stale-file check
+    const stale = config.workspace.filter((e) => !fileExists(e.path));
+    if (stale.length) {
+        console.log('\nThe following tracked files no longer exist on disk:');
+        stale.forEach((e) => console.log(`  - ${e.path}  (${e.name})`));
+        const { cleanup } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'cleanup',
+                message: 'Remove these entries from the workspace config?',
+                default: true,
+            },
+        ]);
+        if (cleanup) {
+            config.workspace = config.workspace.filter((e) => fileExists(e.path));
+            writeConfig(config);
+        }
+    }
+
+    const token = await getToken();
+
+    // ── pull existing tracked entries ─────────────────────────────────────────
+    if (config.workspace.length) {
+        console.log('Fetching remote code...');
+        const remoteCodeMap = await fetchRemoteCode(token, ripUrl, config.workspace);
+
+        const classified = config.workspace.map((entry) => {
+            const key = `${entry.object_type}:${entry.id}`;
+            const remoteCode = remoteCodeMap.get(key) ?? null;
+            const localCode = readCodeFile(entry.path);
+
+            const remoteChecksum = computeChecksum(remoteCode ?? '');
+            const localChecksum = computeChecksum(localCode ?? '');
+            const pullChecksum = entry.checksum_at_pull;
+
+            let status;
+            if (pullChecksum === localChecksum && pullChecksum === remoteChecksum) {
+                status = 'unchanged';
+            } else if (pullChecksum === localChecksum) {
+                status = 'fast-forward';
+            } else {
+                status = 'conflict';
+            }
+
+            return { ...entry, remoteCode, status };
+        });
+
+        const changed = classified.filter((e) => e.status !== 'unchanged');
+
+        if (!changed.length) {
+            console.log('Everything is up to date.');
+        } else {
+            const selected = await selectEntries(changed, 'pull (overwrites local files)');
+
+            if (!selected.length) {
+                console.log('Nothing selected. No changes made.');
+            } else {
+                for (const entry of selected) {
+                    writeCodeFile(entry.path, entry.remoteCode);
+                    const idx = config.workspace.findIndex(
+                        (e) => e.id === entry.id && e.object_type === entry.object_type,
+                    );
+                    if (idx !== -1) {
+                        config.workspace[idx].checksum_at_pull = computeChecksum(entry.remoteCode);
+                    }
+                }
+                writeConfig(config);
+                console.log(`\nPulled ${selected.length} record(s).`);
+            }
+        }
+    } else {
+        console.log('No tracked resources. Run `agrippa clone` first.');
+    }
+
+    // ── discover new phases on tracked workflows ──────────────────────────────
+    await discoverNewPhases(token, ripUrl, config);
+}
+
+async function discoverNewPhases(token, ripUrl, config) {
+    // Build map of workflow_id → { workflow_name, basePath } from existing phase entries
+    const workflows = new Map();
+    for (const entry of config.workspace) {
+        if (entry.object_type === 'phase' && entry.workflow_id && !workflows.has(entry.workflow_id)) {
+            workflows.set(entry.workflow_id, {
+                name: entry.workflow_name,
+                basePath: dirname(entry.path),
+            });
+        }
+    }
+
+    if (!workflows.size) return;
+
+    const trackedIds = new Set(
+        config.workspace.filter((e) => e.object_type === 'phase').map((e) => e.id),
+    );
+
+    let newCount = 0;
+    for (const [wfId, { name: wfName, basePath }] of workflows) {
+        const phases = await getPhasesByWorkflow(token, ripUrl, wfId, { fromCode: true });
+        for (const phase of phases) {
+            if (trackedIds.has(phase.id)) continue;
+            const filePath = `${basePath}/${toSlug(phase.name)}.py`;
+            writeCodeFile(filePath, phase.code);
+            config.workspace.push({
+                path: filePath,
+                id: phase.id,
+                object_type: 'phase',
+                workflow_id: wfId,
+                workflow_name: wfName,
+                checksum_at_pull: computeChecksum(phase.code),
+                name: `${wfName} / ${phase.name}`,
+            });
+            console.log(`  new phase: ${filePath}`);
+            newCount++;
+        }
+    }
+
+    if (newCount) {
+        writeConfig(config);
+        console.log(`Added ${newCount} new phase(s) from tracked workflows.`);
+    }
+}
+
+// ── shared helpers ────────────────────────────────────────────────────────────
+
+async function fetchRemoteCode(token, ripUrl, workspace) {
+    const map = new Map();
+
+    const phaseEntries = workspace.filter((e) => e.object_type === 'phase');
+    const mfaEntries = workspace.filter((e) => e.object_type === 'mfa');
+
+    if (phaseEntries.length) {
+        const ids = phaseEntries.map((e) => e.id);
+        const phases = await getPhasesByIds(token, ripUrl, ids);
+        phases.forEach((p) => map.set(`phase:${p.id}`, p.code));
+    }
+
+    if (mfaEntries.length) {
+        const allMfas = await listMfas(token, ripUrl);
+        mfaEntries.forEach((e) => {
+            const remote = allMfas.find((m) => m.id === e.id);
+            if (remote) map.set(`mfa:${e.id}`, remote.code);
+        });
+    }
+
+    return map;
+}
+
+async function selectEntries(changed, verb, mode = 'pull') {
+    // Group by parent folder for folder-level pre-selection
+    const folderMap = new Map();
+    for (const entry of changed) {
+        const folder = dirname(entry.path) || '.';
+        if (!folderMap.has(folder)) folderMap.set(folder, []);
+        folderMap.get(folder).push(entry);
+    }
+
+    const folders = [...folderMap.keys()];
+
+    // Folder-level pre-selection (only shown when there are multiple folders)
+    let includedFolders = new Set(folders);
+    if (folders.length > 1) {
+        const { selectedFolders } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedFolders',
+                message: `Select workflows/folders to ${verb}:`,
+                choices: folders.map((f) => ({
+                    name: `${f}/  (${folderMap.get(f).length} changed)`,
+                    value: f,
+                    checked: true,
+                })),
+            },
+        ]);
+        includedFolders = new Set(selectedFolders);
+    }
+
+    const candidates = changed.filter((e) => includedFolders.has(dirname(e.path) || '.'));
+
+    if (!candidates.length) return [];
+
+    const badgeFor = (status) => {
+        if (mode === 'push') {
+            return status === 'fast-forward' ? '↑ local updated' : '⚠ remote changes will be overwritten';
+        }
+        return status === 'fast-forward' ? '↑ remote updated' : '⚠ local changes will be lost';
+    };
+
+    const { selected } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selected',
+            message: `Fine-tune records to ${verb}: (space to toggle, a to toggle all)`,
+            choices: candidates.map((e) => ({
+                name: `[${dirname(e.path) || '.'}]  ${e.name}  [${badgeFor(e.status)}]`,
+                value: e,
+                checked: true,
+            })),
+            pageSize: 20,
+        },
+    ]);
+
+    return selected;
+}
+
+export { pull, fetchRemoteCode, selectEntries };

package/src/agrippa/commands/push.js

@@ -0,0 +1,126 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import inquirer from 'inquirer';
+import { readConfig, writeConfig, loadEffectiveEnv } from '../lib/config.js';
+import { updatePhase, updateMfa } from '../lib/api.js';
+import { getToken } from '../../lib/auth.js';
+import { computeChecksum } from '../lib/checksum.js';
+import { readCodeFile, fileExists } from '../lib/workspace.js';
+import { fetchRemoteCode, selectEntries } from './pull.js';
+
+const BACKUP_DIR = '.backup';
+
+async function push() {
+    const config = readConfig();
+    loadEffectiveEnv(config);
+
+    const ripUrl = process.env.RIP_URL;
+    if (!ripUrl) throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+
+    // Stale-file check
+    const stale = config.workspace.filter((e) => !fileExists(e.path));
+    if (stale.length) {
+        console.log('\nThe following tracked files no longer exist on disk:');
+        stale.forEach((e) => console.log(`  - ${e.path}  (${e.name})`));
+        const { cleanup } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'cleanup',
+                message: 'Remove these entries from the workspace config?',
+                default: true,
+            },
+        ]);
+        if (cleanup) {
+            config.workspace = config.workspace.filter((e) => fileExists(e.path));
+            writeConfig(config);
+        }
+    }
+
+    if (!config.workspace.length) {
+        console.log('No tracked resources. Run `agrippa clone` first.');
+        return;
+    }
+
+    console.log('Fetching remote code...');
+    const token = await getToken();
+
+    const remoteCodeMap = await fetchRemoteCode(token, ripUrl, config.workspace);
+
+    // Classify — concern here is remote work being overwritten
+    const classified = config.workspace.map((entry) => {
+        const key = `${entry.object_type}:${entry.id}`;
+        const remoteCode = remoteCodeMap.get(key) ?? null;
+        const localCode = readCodeFile(entry.path);
+
+        const remoteChecksum = computeChecksum(remoteCode ?? '');
+        const localChecksum = computeChecksum(localCode ?? '');
+        const pullChecksum = entry.checksum_at_pull;
+
+        let status;
+        if (pullChecksum === localChecksum && pullChecksum === remoteChecksum) {
+            status = 'unchanged';
+        } else if (pullChecksum === remoteChecksum) {
+            // remote untouched since last pull, local has new changes
+            status = 'fast-forward';
+        } else {
+            // remote changed since last pull — pushing will overwrite remote work
+            status = 'conflict';
+        }
+
+        return { ...entry, remoteCode, localCode, status };
+    });
+
+    const changed = classified.filter((e) => e.status !== 'unchanged');
+
+    if (!changed.length) {
+        console.log('Nothing to push — local files match the last-pulled state.');
+        return;
+    }
+
+    const selected = await selectEntries(changed, 'push (overwrites remote code)', 'push');
+
+    if (!selected.length) {
+        console.log('Nothing selected. No changes made.');
+        return;
+    }
+
+    // Write backups of remote code before overwriting
+    const backupTs = new Date()
+        .toISOString()
+        .replace(/:/g, '-')
+        .replace('T', '_')
+        .slice(0, 19);
+
+    for (const entry of selected) {
+        if (entry.remoteCode !== null) {
+            const backupPath = join(BACKUP_DIR, backupTs, entry.path);
+            mkdirSync(dirname(backupPath), { recursive: true });
+            writeFileSync(backupPath, (entry.remoteCode ?? '').trim() + '\n', 'utf-8');
+        }
+    }
+    console.log(`Remote backups written to ${BACKUP_DIR}/${backupTs}/`);
+
+    // Push local code to API
+    let pushed = 0;
+    for (const entry of selected) {
+        const code = entry.localCode ?? '';
+        if (entry.object_type === 'phase') {
+            await updatePhase(token, ripUrl, entry.id, code);
+        } else {
+            await updateMfa(token, ripUrl, entry.id, code);
+        }
+
+        const idx = config.workspace.findIndex(
+            (e) => e.id === entry.id && e.object_type === entry.object_type,
+        );
+        if (idx !== -1) {
+            config.workspace[idx].checksum_at_pull = computeChecksum(code);
+        }
+        pushed++;
+    }
+
+    writeConfig(config);
+    console.log(`\nPushed ${pushed} record(s).`);
+}
+
+export { push };

package/src/agrippa/commands/repair.js

@@ -0,0 +1,24 @@
+import { readConfig, writeConfig } from '../lib/config.js';
+import { fileExists } from '../lib/workspace.js';
+
+async function repair() {
+    const config = readConfig();
+    const before = config.workspace.length;
+
+    const stale = config.workspace.filter((entry) => !fileExists(entry.path));
+    config.workspace = config.workspace.filter((entry) => fileExists(entry.path));
+
+    if (!stale.length) {
+        console.log('No stale entries found.');
+        return;
+    }
+
+    for (const entry of stale) {
+        console.log(`  removed: ${entry.path} (${entry.name})`);
+    }
+
+    writeConfig(config);
+    console.log(`Removed ${stale.length} stale entr${stale.length === 1 ? 'y' : 'ies'} (${before} → ${config.workspace.length}).`);
+}
+
+export { repair };

package/src/agrippa/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { program } from 'commander';
+import { init } from './commands/init.js';
+import { clone } from './commands/clone.js';
+import { pull } from './commands/pull.js';
+import { push } from './commands/push.js';
+import { diff } from './commands/diff.js';
+import { initPhase } from './commands/initPhase.js';
+import { repair } from './commands/repair.js';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+
+process.on('unhandledRejection', (err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+});
+
+program.name('agrippa').version(version);
+
+program
+    .command('init')
+    .description('Create agrippa.yaml workspace config in the current directory')
+    .action(() => init().catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('clone')
+    .description('Clone a phase or MFA from RIP into this workspace')
+    .option('--phase', 'Clone a phase (select a workflow)')
+    .option('--mfa', 'Clone a Model Function Access record')
+    .option('--id <id>', 'Record ID to clone')
+    .option('--path <path>', 'Destination path (file for MFA, base dir for workflow)')
+    .action((opts) => clone(opts).catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('pull')
+    .description('Pull remote changes into local files')
+    .action(() => pull().catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('push')
+    .description('Push local changes to RIP (backs up remote code first)')
+    .action(() => push().catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('diff [path]')
+    .description('Show differences between local files and remote code')
+    .action((path) => diff(path).catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('init-phase')
+    .description('Initialize a phase with default code template and result vars')
+    .action(() => initPhase().catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program
+    .command('repair')
+    .description('Remove stale workspace entries where local file no longer exists')
+    .action(() => repair().catch((err) => { console.error(`Error: ${err.message}`); process.exit(1); }));
+
+program.parse();

package/src/agrippa/lib/api.js

@@ -0,0 +1,106 @@
+import fetch from 'node-fetch';
+
+async function makeRequest(method, path, token, ripUrl, body) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        ...(method !== 'GET' ? { 'Content-Type': 'application/json' } : {}),
+    };
+    const res = await fetch(`${ripUrl}${path}`, {
+        method,
+        headers,
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        throw new Error(`API ${method} ${path} failed with ${res.status}: ${await res.text()}`);
+    }
+    return res.json();
+}
+
+function listWorkflows(token, ripUrl) {
+    return makeRequest('GET', '/symple.workflow/*', token, ripUrl);
+}
+
+function getPhasesByWorkflow(token, ripUrl, workflowId, { fromCode = false } = {}) {
+    const filter = fromCode
+        ? `[('workflow_id', '=', ${workflowId}), ('set_result_automatically', '=', 'from_code')]`
+        : `[('workflow_id', '=', ${workflowId})]`;
+    return makeRequest('GET', `/symple.triplet.phase/*?_filter_=${filter}`, token, ripUrl);
+}
+
+function getPhasesByIds(token, ripUrl, ids) {
+    return makeRequest(
+        'GET',
+        `/symple.triplet.phase/*?_filter_=[('id', 'in', [${ids.join(',')}])]`,
+        token,
+        ripUrl,
+    );
+}
+
+function updatePhase(token, ripUrl, phaseId, code) {
+    return makeRequest('PUT', `/symple.triplet.phase/${phaseId}`, token, ripUrl, { code });
+}
+
+function listMfas(token, ripUrl) {
+    return makeRequest('GET', '/symple.workflow/get_mfas', token, ripUrl);
+}
+
+function updateMfa(token, ripUrl, mfaId, code) {
+    return makeRequest('POST', '/symple.workflow/update_mfa', token, ripUrl, { id: mfaId, code });
+}
+
+async function getPhaseResults(token, ripUrl, phaseId) {
+    try {
+        return await makeRequest(
+            'GET',
+            `/symple.triplet.phase.result/*?_filter_=[('code_phase_id', '=', ${phaseId})]`,
+            token,
+            ripUrl,
+        );
+    } catch (err) {
+        if (err.message.includes('404')) return [];
+        throw err;
+    }
+}
+
+function initPhaseRemote(token, ripUrl, phaseId, code) {
+    return makeRequest('PUT', `/symple.triplet.phase/${phaseId}`, token, ripUrl, {
+        set_result_automatically: 'from_code',
+        code,
+    });
+}
+
+async function getPhaseConfigurators(token, ripUrl, phaseId) {
+    try {
+        return await makeRequest(
+            'GET',
+            `/result.code.configurator/*?_filter_=[('code_phase_id', '=', ${phaseId})]`,
+            token,
+            ripUrl,
+        );
+    } catch (err) {
+        if (err.message.includes('404')) return [];
+        throw err;
+    }
+}
+
+function deleteConfigurator(token, ripUrl, id) {
+    return makeRequest('DELETE', `/result.code.configurator/${id}`, token, ripUrl);
+}
+
+function createConfigurator(token, ripUrl, data) {
+    return makeRequest('POST', `/result.code.configurator`, token, ripUrl, data);
+}
+
+export {
+    listWorkflows,
+    getPhasesByWorkflow,
+    getPhasesByIds,
+    updatePhase,
+    listMfas,
+    updateMfa,
+    getPhaseResults,
+    initPhaseRemote,
+    getPhaseConfigurators,
+    deleteConfigurator,
+    createConfigurator,
+};

package/src/agrippa/lib/checksum.js

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto';
+
+function computeChecksum(code) {
+    return createHash('md5').update((code ?? '').trim()).digest('hex');
+}
+
+export { computeChecksum };

package/src/agrippa/lib/config.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { parse, stringify } from 'yaml';
+import { configDotenv } from 'dotenv';
+import { CONFIG_FILE } from '../../config.js';
+
+const WORKSPACE_FILE = 'agrippa.yaml';
+
+function readConfig() {
+    if (!existsSync(WORKSPACE_FILE)) {
+        throw new Error('agrippa.yaml not found in current directory. Run `agrippa init` first.');
+    }
+    return parse(readFileSync(WORKSPACE_FILE, 'utf-8'));
+}
+
+function writeConfig(config) {
+    writeFileSync(WORKSPACE_FILE, stringify(config, { lineWidth: 0 }), 'utf-8');
+}
+
+function loadEffectiveEnv(localConfig) {
+    // Load global prbot config as the base (KC_URL, KC_USER, RIP_URL, etc. live here)
+    if (existsSync(CONFIG_FILE)) {
+        configDotenv({ path: CONFIG_FILE });
+    }
+
+    // Overlay workspace-level overrides from agrippa.yaml's agrippa: section
+    const overrides = localConfig?.agrippa ?? {};
+    const keys = ['KC_URL', 'KC_USER', 'KC_PASSWORD', 'KC_ID', 'KC_SECRET', 'RIP_URL'];
+    for (const key of keys) {
+        if (overrides[key]) {
+            process.env[key] = overrides[key];
+        }
+    }
+}
+
+export { readConfig, writeConfig, loadEffectiveEnv, WORKSPACE_FILE };

package/src/agrippa/lib/workspace.js

@@ -0,0 +1,42 @@
+import slugify from 'slugify';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
+import { dirname } from 'path';
+
+function toSlug(name) {
+    return slugify(name, { lower: true, strict: true });
+}
+
+function defaultPhasePath(workflowName, phaseName) {
+    return `${toSlug(workflowName)}/${toSlug(phaseName)}.py`;
+}
+
+function toMfaSlug(name) {
+    return slugify(name, { lower: true, replacement: '_' });
+}
+
+function defaultMfaPath(modelName, mfaName) {
+    return `${modelName}/${toMfaSlug(mfaName)}.py`;
+}
+
+function ensureDir(filePath) {
+    const dir = dirname(filePath);
+    if (dir && dir !== '.') {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+
+function writeCodeFile(filePath, content) {
+    ensureDir(filePath);
+    writeFileSync(filePath, (content ?? '').trim() + '\n', 'utf-8');
+}
+
+function readCodeFile(filePath) {
+    if (!existsSync(filePath)) return null;
+    return readFileSync(filePath, 'utf-8');
+}
+
+function fileExists(filePath) {
+    return existsSync(filePath);
+}
+
+export { toSlug, defaultPhasePath, defaultMfaPath, ensureDir, writeCodeFile, readCodeFile, fileExists };

package/src/commands/autopr.js

@@ -73,6 +73,10 @@ function buildPrDescription(taskIds, jiras) {
 async function createDevopsPR(branch, title, description) {
     const { DEVOPS_ORG, DEVOPS_PROJECT, DEVOPS_REPO, AUTOPR_TARGET_BRANCH } = process.env;
     const apiUrl = `https://dev.azure.com/${DEVOPS_ORG}/${DEVOPS_PROJECT}/_apis/git/repositories/${DEVOPS_REPO}/pullrequests?api-version=7.0`;
+    const reviewers = process.env.AUTOPR_REQUIRED_REVIEWER_ID
+        ? [{ id: process.env.AUTOPR_REQUIRED_REVIEWER_ID, isRequired: true }]
+        : [];
+
     const res = await fetch(apiUrl, {
         method: 'POST',
         headers: devopsHeaders(),
@@ -82,6 +86,7 @@ async function createDevopsPR(branch, title, description) {
             isDraft: true,
             sourceRefName: `refs/heads/${branch}`,
             targetRefName: `refs/heads/${AUTOPR_TARGET_BRANCH}`,
+            reviewers,
         }),
     });
     const data = await res.json();

package/src/commands/export.js

@@ -1,9 +1,10 @@
 import { exportPb } from './exportPb.js';
 import { exportImperex } from './exportImperex.js';
 import { exportEmailTemplates } from './exportEmailTemplates.js';
+import { exportWorkflow } from './exportWorkflow.js';
 
 function exportRip() {
     console.log('Not implemented yet.');
 }
 
-export { exportPb, exportRip, exportImperex, exportEmailTemplates };
+export { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow };