@waron97/prbot 2.8.0 → 3.0.1

package/agrippa_typings/recordset.pyi

@@ -0,0 +1,38 @@
+"""Shared Recordset base class for all Odoo models."""
+
+from typing import Any, Dict, List, Optional, Union, Iterator
+import datetime as _dt
+
+class Recordset:
+    """Base class for all Odoo model record objects."""
+
+    id: int
+    ids: List[int]
+    create_date: _dt.date
+    write_date: _dt.date
+    create_uid: "Recordset"
+    write_uid: "Recordset"
+    def __getattr__(self, name: str) -> Any: ...
+    def browse(self, ids: Union[int, List[int]]) -> "Recordset": ...
+    def write(self, vals: Dict[str, Any]) -> bool: ...
+    def search(
+        self,
+        domain: List[Any],
+        limit: Optional[int] = None,
+        order: Optional[str] = None,
+        offset: int = 0,
+    ) -> "Recordset": ...
+    def create(self, vals: Dict[str, Any]) -> "Recordset": ...
+    def sudo(self) -> "Recordset": ...
+    def with_context(self, ctx: Dict[str, Any] = ..., **kwargs: Any) -> "Recordset": ...
+    def filtered(self, func: Any) -> "Recordset": ...
+    def mapped(self, field: str) -> Any: ...
+    def sorted(self, key: Any = None, reverse: bool = False) -> "Recordset": ...
+    def exists(self) -> "Recordset": ...
+    def unlink(self) -> bool: ...
+    def get_payload(self) -> Any: ...
+    def __getitem__(self, key: Union[str, int]) -> Any: ...
+    def __setitem__(self, key: str, value: Any) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __iter__(self) -> Iterator["Recordset"]: ...
+    def __len__(self) -> int: ...

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@waron97/prbot",
-    "version": "2.8.0",
+    "version": "3.0.1",
     "description": "",
     "main": "index.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "bin": {
-        "prbot": "src/index.js"
+        "prbot": "src/index.js",
+        "agrippa": "src/agrippa/index.js"
     },
     "dependencies": {
         "@inquirer/search": "^2.0.1",
@@ -18,7 +19,9 @@
         "inquirer-search-list": "^1.2.6",
         "node-fetch": "^3.3.2",
         "omelette": "^0.4.17",
-        "prettier": "^3.5.3"
+        "prettier": "^3.5.3",
+        "slugify": "^1.6.9",
+        "yaml": "^2.9.0"
     },
     "devDependencies": {
         "@eslint/js": "^9.21.0",
@@ -28,6 +31,10 @@
         "typescript": "^5.8.2",
         "typescript-eslint": "^8.26.0"
     },
+    "files": [
+        "src/",
+        "agrippa_typings/"
+    ],
     "keywords": [],
     "author": "",
     "license": "ISC",

package/src/agrippa/commands/clone.js

@@ -0,0 +1,134 @@
+import inquirer from 'inquirer';
+import select from '@inquirer/select';
+import search from '@inquirer/search';
+import { readConfig, writeConfig, loadEffectiveEnv } from '../lib/config.js';
+import { listWorkflows, getPhasesByWorkflow, listMfas } from '../lib/api.js';
+import { getToken } from '../../lib/auth.js';
+import { computeChecksum } from '../lib/checksum.js';
+import { toSlug, defaultMfaPath, writeCodeFile } from '../lib/workspace.js';
+import { fuzzyMatch } from '../../lib/fuzzy.js';
+
+async function clone(opts) {
+    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.');
+
+    // Determine object type
+    let objectType = opts.mfa ? 'mfa' : opts.phase ? 'phase' : null;
+    if (!objectType) {
+        objectType = await select({
+            message: 'What do you want to clone?',
+            choices: [
+                { name: 'MFA', value: 'mfa' },
+                { name: 'Phase', value: 'phase' },
+            ],
+        });
+    }
+
+    console.log('Fetching records...');
+    const token = await getToken();
+
+    let records;
+    if (objectType === 'phase') {
+        records = await listWorkflows(token, ripUrl);
+    } else {
+        records = await listMfas(token, ripUrl);
+    }
+
+    if (!records.length) {
+        console.log(`No ${objectType} records found.`);
+        return;
+    }
+
+    // Determine record
+    let record;
+    if (opts.id) {
+        const id = parseInt(opts.id, 10);
+        record = records.find((r) => r.id === id);
+        if (!record) throw new Error(`No ${objectType} found with id ${opts.id}`);
+    } else {
+        record = await search({
+            message: `Select a ${objectType}:`,
+            source: (input) => {
+                const filtered = input
+                    ? records.filter((r) => fuzzyMatch(r.name, input))
+                    : records;
+                return filtered.map((r) => ({
+                    name: objectType === 'mfa' ? `${r.model_name} / ${r.name}` : r.name,
+                    value: r,
+                }));
+            },
+        });
+    }
+
+    // Determine path
+    let basePath = opts.path ?? null;
+
+    if (objectType === 'phase') {
+        if (!basePath) {
+            const { inputPath } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'inputPath',
+                    message: 'Base directory for phases:',
+                    default: toSlug(record.name),
+                },
+            ]);
+            basePath = inputPath;
+        }
+
+        console.log(`Fetching phases for "${record.name}"...`);
+        const phases = await getPhasesByWorkflow(token, ripUrl, record.id, { fromCode: true });
+
+        if (!phases.length) {
+            console.log('No phases found.');
+            return;
+        }
+
+        for (const phase of phases) {
+            const filePath = `${basePath}/${toSlug(phase.name)}.py`;
+            writeCodeFile(filePath, phase.code);
+            config.workspace.push({
+                path: filePath,
+                id: phase.id,
+                object_type: 'phase',
+                workflow_id: record.id,
+                workflow_name: record.name,
+                checksum_at_pull: computeChecksum(phase.code),
+                name: `${record.name} / ${phase.name}`,
+            });
+            console.log(`  wrote ${filePath}`);
+        }
+
+        console.log(`Cloned ${phases.length} phase(s) to ${basePath}/`);
+    } else {
+        const defaultPath = defaultMfaPath(record.model_name, record.name);
+        if (!basePath) {
+            const { inputPath } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'inputPath',
+                    message: 'Path for MFA file:',
+                    default: defaultPath,
+                },
+            ]);
+            basePath = inputPath;
+        }
+
+        writeCodeFile(basePath, record.code);
+        config.workspace.push({
+            path: basePath,
+            id: record.id,
+            object_type: 'mfa',
+            checksum_at_pull: computeChecksum(record.code),
+            name: `${record.model_name} / ${record.name}`,
+        });
+        console.log(`Cloned MFA to ${basePath}`);
+    }
+
+    writeConfig(config);
+}
+
+export { clone };

package/src/agrippa/commands/diff.js

@@ -0,0 +1,96 @@
+import { existsSync, statSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { spawnSync } from 'child_process';
+import { readConfig, loadEffectiveEnv } from '../lib/config.js';
+import { fetchRemoteCode } from './pull.js';
+import { getToken } from '../../lib/auth.js';
+import { readCodeFile, fileExists } from '../lib/workspace.js';
+import { computeChecksum } from '../lib/checksum.js';
+
+async function diff(targetArg) {
+    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.');
+
+    if (!config.workspace.length) {
+        console.log('No tracked resources. Run `agrippa clone` first.');
+        return;
+    }
+
+    const entries = filterEntries(config.workspace, targetArg);
+    if (!entries.length) {
+        console.log('No tracked files match the given path.');
+        return;
+    }
+
+    console.log('Fetching remote code...');
+    const token = await getToken();
+    const remoteCodeMap = await fetchRemoteCode(token, ripUrl, entries);
+
+    let diffCount = 0;
+    const tmpFiles = [];
+
+    try {
+        for (const entry of entries) {
+            const key = `${entry.object_type}:${entry.id}`;
+            const remoteCode = remoteCodeMap.get(key) ?? '';
+            const localCode = readCodeFile(entry.path) ?? '';
+
+            if (computeChecksum(localCode) === computeChecksum(remoteCode)) continue;
+
+            if (!fileExists(entry.path)) {
+                console.log(`\n--- ${entry.path} (local file missing)`);
+                continue;
+            }
+
+            // Write remote content to a temp file so git diff --no-index can compare
+            const tmpPath = join(tmpdir(), `agrippa-remote-${entry.object_type}-${entry.id}.py`);
+            writeFileSync(tmpPath, (remoteCode ?? '').trim() + '\n', 'utf-8');
+            tmpFiles.push(tmpPath);
+
+            console.log(`\n=== ${entry.path}  [${entry.name}] ===`);
+
+            const result = spawnSync(
+                'git',
+                ['diff', '--no-index', '--color=always', tmpPath, entry.path],
+                { stdio: ['ignore', 'inherit', 'inherit'] },
+            );
+            // exit code 1 means differences found (normal), 0 means identical, >1 means error
+            if (result.status !== null && result.status > 1) {
+                console.error(`git diff failed for ${entry.path}`);
+            }
+            diffCount++;
+        }
+    } finally {
+        for (const f of tmpFiles) {
+            try { unlinkSync(f); } catch { /* ignore */ }
+        }
+    }
+
+    if (diffCount === 0) {
+        console.log('No differences found — all tracked files match the remote.');
+    } else {
+        console.log(`\n${diffCount} file(s) differ from remote.`);
+    }
+}
+
+function filterEntries(workspace, targetArg) {
+    if (!targetArg) return workspace;
+
+    // Normalise: strip trailing slash
+    const target = targetArg.replace(/\/$/, '');
+
+    // If it exists on disk and is a directory, filter by prefix
+    if (existsSync(target) && statSync(target).isDirectory()) {
+        const prefix = target.endsWith('/') ? target : target + '/';
+        return workspace.filter((e) => e.path.startsWith(prefix));
+    }
+
+    // Otherwise treat as exact file path (whether it exists yet or not)
+    return workspace.filter((e) => e.path === target);
+}
+
+export { diff };

package/src/agrippa/commands/init.js

@@ -0,0 +1,116 @@
+import { existsSync, writeFileSync, mkdirSync, copyFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { join } from 'path';
+import inquirer from 'inquirer';
+import { WORKSPACE_FILE } from '../lib/config.js';
+
+const TEMPLATE = `# agrippa workspace configuration
+# Keycloak and RIP credentials are taken from the global prbot config by default.
+# Uncomment and set values here only to override them for this workspace.
+agrippa: {}
+  # KC_URL: ""
+  # KC_USER: ""
+  # KC_PASSWORD: ""
+  # KC_ID: ""
+  # KC_SECRET: ""
+  # RIP_URL: ""
+
+workspace: []
+`;
+
+const PYPROJECT_TOML = `[tool.ruff]
+builtins = [
+    "case_id",
+    "request",
+    "format_exc",
+    "env",
+    "log",
+    "json_dumps",
+    "ValidationError",
+    "datetime",
+    "date",
+    "dateutil",
+    "time",
+    "pytz",
+    "body",
+    "make_response",
+    "logger",
+    "first",
+    "args",
+    "model",
+    "json_loads",
+    "record",
+    "records"
+]
+`;
+
+const PYRIGHTCONFIG = JSON.stringify(
+    {
+        pythonVersion: '3.10',
+        stubPath: 'typings',
+        typeCheckingMode: 'standard',
+        reportArgumentType: 'none',
+    },
+    null,
+    2,
+) + '\n';
+
+const TYPING_FILES = [
+    '__builtins__.pyi',
+    'odoo_environment.pyi',
+    'odoo_records.pyi',
+    'recordset.pyi',
+    'b2w_entities.pyi',
+];
+
+async function init() {
+    if (existsSync(WORKSPACE_FILE)) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `${WORKSPACE_FILE} already exists. Overwrite?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            console.log('Aborted.');
+            return;
+        }
+    }
+
+    writeFileSync(WORKSPACE_FILE, TEMPLATE, 'utf-8');
+    console.log(`Created ${WORKSPACE_FILE}`);
+    console.log(`Run 'agrippa clone' to add resources to this workspace.`);
+    console.log(`Add ${WORKSPACE_FILE} to .gitignore if it contains credentials.`);
+
+    if (!existsSync('pyproject.toml')) {
+        writeFileSync('pyproject.toml', PYPROJECT_TOML, 'utf-8');
+        console.log('Created pyproject.toml (ruff builtins)');
+    }
+
+    const { importTypings } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'importTypings',
+            message: 'Import pyright config and type stubs?',
+            default: true,
+        },
+    ]);
+
+    if (importTypings) {
+        if (!existsSync('pyrightconfig.json')) {
+            writeFileSync('pyrightconfig.json', PYRIGHTCONFIG, 'utf-8');
+            console.log('Created pyrightconfig.json');
+        }
+
+        const typingsDir = fileURLToPath(new URL('../../../agrippa_typings', import.meta.url));
+        mkdirSync('typings', { recursive: true });
+        for (const file of TYPING_FILES) {
+            copyFileSync(join(typingsDir, file), join('typings', file));
+        }
+        console.log(`Copied ${TYPING_FILES.length} type stubs to typings/`);
+    }
+}
+
+export { init };

package/src/agrippa/commands/initPhase.js

@@ -0,0 +1,162 @@
+import inquirer from 'inquirer';
+import search from '@inquirer/search';
+import { readConfig, loadEffectiveEnv } from '../lib/config.js';
+import {
+    listWorkflows,
+    getPhasesByWorkflow,
+    getPhaseResults,
+    initPhaseRemote,
+    getPhaseConfigurators,
+    deleteConfigurator,
+    createConfigurator,
+} from '../lib/api.js';
+import { getToken } from '../../lib/auth.js';
+import { fuzzyMatch } from '../../lib/fuzzy.js';
+
+const CODE_TEMPLATE = `logs = []
+debug_logs = []
+error_occurred = False
+
+
+def make_log(message, data=None, always=False):
+    log_entry = {"message": message}
+    if data is not None:
+        log_entry["data"] = data
+
+    if always:
+        logs.append(log_entry)
+    else:
+        debug_logs.append(log_entry)
+
+
+# --------------------------------------
+
+
+def main():
+    pass
+
+
+try:
+    result = main()
+except Exception as e:
+    error_occurred = True
+    make_log(
+        "Error occurred in phase",
+        {"error": str(e), "traceback": format_exc()},
+        always=True,
+    )
+    case_id.write({"error_message": str(e)})
+
+
+if error_occurred and debug_logs:
+    logs.append({"message": "debug_logs", "logs": debug_logs})
+
+if logs:
+    log(json_dumps(logs, indent=2))`;
+
+function generateCode(results) {
+    if (!results || results.length === 0) return CODE_TEMPLATE;
+
+    const lines = [];
+    const vars = results.map((_, i) => `RES${i + 1}`);
+    results.forEach((r, i) => lines.push(`# ${vars[i]} = ${r.name}`));
+    lines.push('');
+    lines.push(`${vars.join(', ')} = (${vars.map((v) => `"${v}"`).join(', ')})`);
+    lines.push('');
+    lines.push(CODE_TEMPLATE);
+    return lines.join('\n');
+}
+
+async function initPhase() {
+    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.');
+
+    console.log('Fetching workflows...');
+    const token = await getToken();
+    const workflows = await listWorkflows(token, ripUrl);
+
+    if (!workflows.length) {
+        console.log('No workflows found.');
+        return;
+    }
+
+    const workflow = await search({
+        message: 'Select a workflow:',
+        source: (input) => {
+            const filtered = input
+                ? workflows.filter((w) => fuzzyMatch(w.name, input))
+                : workflows;
+            return filtered.map((w) => ({ name: w.name, value: w }));
+        },
+    });
+
+    console.log(`Fetching phases for "${workflow.name}"...`);
+    const phases = await getPhasesByWorkflow(token, ripUrl, workflow.id);
+
+    if (!phases.length) {
+        console.log('No phases found for this workflow.');
+        return;
+    }
+
+    const phase = await search({
+        message: 'Select a phase:',
+        source: (input) => {
+            const filtered = input
+                ? phases.filter((p) => fuzzyMatch(p.name, input))
+                : phases;
+            return filtered.map((p) => ({ name: p.name, value: p }));
+        },
+    });
+
+    // Resolve result objects — API may return IDs or full objects
+    let results = phase.allowed_phase_result_ids || [];
+    if (results.length > 0 && typeof results[0] === 'number') {
+        results = await getPhaseResults(token, ripUrl, phase.id);
+    }
+
+    const code = generateCode(results);
+
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Initialize phase "${phase.name}"? This will overwrite existing code.`,
+            default: true,
+        },
+    ]);
+
+    if (!confirm) {
+        console.log('Aborted.');
+        return;
+    }
+
+    // Delete existing configurator records for this phase
+    const existing = await getPhaseConfigurators(token, ripUrl, phase.id);
+    for (const cfg of existing) {
+        await deleteConfigurator(token, ripUrl, cfg.id);
+    }
+
+    // Update phase code + set_result_automatically
+    await initPhaseRemote(token, ripUrl, phase.id, code);
+
+    // Create new configurator records for each result
+    const vars = results.map((_, i) => `RES${i + 1}`);
+    for (let i = 0; i < results.length; i++) {
+        await createConfigurator(token, ripUrl, {
+            result_value: vars[i],
+            code_phase_id: phase.id,
+            triplet_phase_result_id: results[i].id,
+        });
+    }
+
+    console.log(`Initialized phase "${phase.name}".`);
+    if (results.length > 0) {
+        console.log(`  ${results.length} configurator(s) created: ${vars.join(', ')}`);
+    }
+    console.log(`Run 'agrippa pull' in workspaces that track this workflow to fetch the updated code.`);
+}
+
+export { initPhase };