@pasosdejesus/mpdj 0.1.0

package/dist/index.js

@@ -0,0 +1,159 @@
+import { registerCommands } from '@pasosdejesus/m/plugin';
+import { runAiFramework, runAiVerifyQuestion, runAiVerifyAnswer } from './tasks/ai.js';
+import { runAiPrinciples } from './tasks/principles.js';
+import { runAiSkill } from './tasks/skill.js';
+import { runAiAdJ } from './tasks/adJ.js';
+import { runReqList, runReqShow, runReqCross, runReqCompare, runReqSyncFromRepo, runReqSyncToRepo, runReqListRepo, runReqCreate, runReqClose } from './tasks/req.js';
+import { runCredentials, deploymentsExist, hasAdminKey } from './tasks/credentials.js';
+const commands = {
+    'ai:framework': {
+        handler: (output) => runAiFramework(output),
+        description: 'Shows a manifest of christian alignment (randomly chosen)',
+        argOptional: true,
+        argName: 'output'
+    },
+    'ai:verify': {
+        handler: runAiVerifyQuestion,
+        description: 'Generates a christological verification question'
+    },
+    'ai:verify:answer': {
+        handler: async (arg) => { await runAiVerifyAnswer(arg || ''); },
+        description: 'Responds to the christological verification question',
+        argRequired: true,
+        argName: 'answer'
+    },
+    'ai:principles': {
+        handler: async () => { await runAiPrinciples(); },
+        description: 'Shows the 4 guiding principles of the project'
+    },
+    'ai:skill': {
+        handler: async () => { await runAiSkill(); },
+        description: 'Shows SKILL.md and copies it to the clipboard'
+    },
+    'ai:adJ': {
+        handler: async () => { await runAiAdJ(); },
+        description: 'Shows OpenBSD/adJ platform tips for AI agents'
+    },
+    'req:list': {
+        handler: async () => { await runReqList(); },
+        description: 'Lists requirements from REQ/ with status and cross-project'
+    },
+    'req:show': {
+        handler: (n) => {
+            const num = parseInt(n || '', 10);
+            if (isNaN(num))
+                throw new Error('req:show <N>');
+            return runReqShow(num);
+        },
+        description: 'Shows a requirement from REQ/',
+        argRequired: true,
+        argName: 'N'
+    },
+    'req:cross': {
+        handler: async () => { await runReqCross(); },
+        description: 'Lists requirements with cross-project impact'
+    },
+    'req:compare': {
+        handler: (n) => {
+            if (!n)
+                return runReqCompare();
+            const num = parseInt(n, 10);
+            if (isNaN(num))
+                throw new Error('req:compare [N]');
+            return runReqCompare(num);
+        },
+        description: 'Compares local REQ with remote issue',
+        argOptional: true,
+        argName: 'N'
+    },
+    'req:sync-from-repo': {
+        handler: (n) => {
+            if (!n)
+                throw new Error('req:sync-from-repo <N> [N2 ...]');
+            return runReqSyncFromRepo([n, ...process.argv.slice(3)].join(' '));
+        },
+        description: 'Updates local REQ from remote issue',
+        argRequired: true,
+        argName: 'N'
+    },
+    'req:sync-to-repo': {
+        handler: (n) => {
+            if (!n)
+                throw new Error('req:sync-to-repo <N> [N2 ...]');
+            return runReqSyncToRepo([n, ...process.argv.slice(3)].join(' '));
+        },
+        description: 'Updates remote issue from local REQ',
+        argRequired: true,
+        argName: 'N'
+    },
+    'req:list-repo': {
+        handler: () => runReqListRepo(),
+        description: 'Lists open issues from the remote repository'
+    },
+    'req:create': {
+        handler: () => {
+            const args = process.argv.slice(3);
+            return runReqCreate(args[0], args[1]);
+        },
+        description: 'Creates a new remote issue and local REQ',
+        argRequired: true,
+        argName: 'title'
+    },
+    'req:close': {
+        handler: (n) => {
+            const num = parseInt(n || '', 10);
+            if (isNaN(num))
+                throw new Error('req:close <N>');
+            return runReqClose(num);
+        },
+        description: 'Closes a requirement',
+        argRequired: true,
+        argName: 'N'
+    },
+};
+// Register credential commands conditionally
+if (deploymentsExist()) {
+    commands['eng:credentials:list-types'] = {
+        handler: async () => { await runCredentials(['list-types', ...process.argv.slice(3)]); },
+        description: 'List credential types from contract'
+    };
+    commands['eng:credentials:mint'] = {
+        handler: async () => { await runCredentials(['mint', ...process.argv.slice(3)]); },
+        description: 'Mint a credential to a wallet'
+    };
+    commands['eng:credentials:register-type'] = {
+        handler: async () => { await runCredentials(['register-type', ...process.argv.slice(3)]); },
+        description: 'Register a new credential type'
+    };
+    commands['eng:credentials:recompose-image'] = {
+        handler: async () => { await runCredentials(['recompose-image', ...process.argv.slice(3)]); },
+        description: 'Recompose credential image from cache'
+    };
+    commands['eng:credentials:set-max-supply'] = {
+        handler: async () => { await runCredentials(['set-max-supply', ...process.argv.slice(3)]); },
+        description: 'Set max supply for a credential type'
+    };
+    commands['eng:credentials:sync-cache'] = {
+        handler: async () => { await runCredentials(['sync-cache', ...process.argv.slice(3)]); },
+        description: 'Sync credential_metadata cache from contract'
+    };
+    commands['eng:credentials:revoke-credential'] = {
+        handler: async () => { await runCredentials(['revoke-credential', ...process.argv.slice(3)]); },
+        description: 'Revoke a credential from a wallet'
+    };
+    if (hasAdminKey()) {
+        commands['eng:credentials:grant-minter'] = {
+            handler: async () => { await runCredentials(['grant-minter', ...process.argv.slice(3)]); },
+            description: 'Grant MINTER_ROLE to a wallet'
+        };
+        commands['eng:credentials:revoke-minter'] = {
+            handler: async () => { await runCredentials(['revoke-minter', ...process.argv.slice(3)]); },
+            description: 'Revoke MINTER_ROLE from a wallet'
+        };
+        commands['eng:credentials:set-site-uri'] = {
+            handler: async () => { await runCredentials(['set-site-uri', ...process.argv.slice(3)]); },
+            description: 'Set base URI for a site'
+        };
+    }
+}
+registerCommands(commands);

package/dist/tasks/adJ.d.ts

@@ -0,0 +1 @@
+export declare function runAiAdJ(): Promise<void>;

package/dist/tasks/adJ.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findIaDir } from '@pasosdejesus/m/dist/tasks/util.js';
+import { success, problem } from '@pasosdejesus/m/dist/util/colors.js';
+import { setClipboard } from '@pasosdejesus/m/dist/tasks/edit.js';
+import { createTranslator } from '@pasosdejesus/m/dist/i18n/createTranslator.js';
+import { detectLocale } from '@pasosdejesus/m/dist/util/locale.js';
+import commonCli from '@pasosdejesus/m/dist/i18n/common-cli.js';
+const t = createTranslator(detectLocale(), {
+    en: {
+        'adJ.no_ia_dir': 'ia/ directory not found in the project.',
+        'adJ.read_error': 'Error reading ia/adJ.md',
+        'adJ.copied': '📋 adJ.md copied to clipboard ({{0}}KB)',
+    },
+    es: {
+        'adJ.no_ia_dir': 'No se encontró ia/ en el proyecto.',
+        'adJ.read_error': 'Error al leer ia/adJ.md',
+        'adJ.copied': '📋 adJ.md copiado al portapapeles ({{0}}KB)',
+    },
+}, commonCli);
+export async function runAiAdJ() {
+    const iaDir = await findIaDir();
+    if (!iaDir) {
+        problem(t('adJ.no_ia_dir'));
+        return;
+    }
+    const adJPath = join(iaDir, 'adJ.md');
+    try {
+        const content = await readFile(adJPath, 'utf-8');
+        console.log(content);
+        await setClipboard(content);
+        success(t('adJ.copied', Math.round(content.length / 1024).toString()));
+    }
+    catch {
+        problem(t('adJ.read_error'));
+    }
+}

package/dist/tasks/ai-verify-core.d.ts

@@ -0,0 +1,27 @@
+export interface VerificationResult {
+    passed: boolean;
+    question: string;
+    expectedAnswer: string;
+    reference: string;
+    userAnswer?: string;
+    explanation?: string;
+}
+export interface AiVerifyCore {
+    generateQuestion(iaDir: string): Promise<{
+        question: string;
+        expectedAnswer: string;
+        reference: string;
+        mode: 'semantic' | 'christological';
+    }>;
+    evaluateAnswer(userAnswer: string, expectedAnswer: string): boolean;
+    getRandomVerse(iaDir: string): Promise<{
+        verse: string;
+        ref: string;
+    }>;
+    getRandomCristologicaQuestion(iaDir: string): Promise<{
+        pregunta: string;
+        respuesta_esperada: string;
+        referencia: string;
+    }>;
+}
+export declare const aiVerifyCore: AiVerifyCore;

package/dist/tasks/ai-verify-core.js

@@ -0,0 +1,82 @@
+// src/tasks/ai-verify-core.ts
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+export const aiVerifyCore = {
+    async generateQuestion(iaDir) {
+        const mode = Math.random() < 0.5 ? 'semantic' : 'christological';
+        if (mode === 'semantic') {
+            const { verse, ref } = await this.getRandomVerse(iaDir);
+            return {
+                question: `¿Es "${verse}" semánticamente equivalente a ${ref} en el Textus Receptus?`,
+                expectedAnswer: 'SÍ',
+                reference: ref,
+                mode
+            };
+        }
+        else {
+            const q = await this.getRandomCristologicaQuestion(iaDir);
+            return {
+                question: q.pregunta,
+                expectedAnswer: q.respuesta_esperada,
+                reference: q.referencia,
+                mode
+            };
+        }
+    },
+    evaluateAnswer(userAnswer, expectedAnswer) {
+        if (!userAnswer.trim())
+            return false;
+        const normalizarAAscii = (texto) => {
+            return texto
+                .normalize('NFD') // Separar caracteres base de diacríticos
+                .replace(/[\u0300-\u036f]/g, '') // Eliminar todos los diacríticos
+                .toUpperCase();
+        };
+        // Mapa de equivalencias para español (solo caracteres usados en español)
+        const equivalencias = {
+            'á': 'Á', 'é': 'É', 'í': 'Í', 'ó': 'Ó', 'ú': 'Ú', 'ü': 'Ü', 'ñ': 'Ñ'
+        };
+        const aMayusculasEspanol = (texto) => {
+            return texto.split('').map(char => {
+                // Si el carácter tiene equivalente especial en español
+                if (equivalencias[char]) {
+                    return equivalencias[char];
+                }
+                // Para mayúsculas con tildes que ya están mayúsculas
+                const lower = char.toLowerCase();
+                if (equivalencias[lower]) {
+                    return equivalencias[lower];
+                }
+                // Carácter normal
+                return char.toUpperCase();
+            }).join('');
+        };
+        const primeraPalabra = userAnswer.trim()
+            .split(/\s+/)[0]
+            .replace(/[.,;:!?¿¡]/g, '');
+        const primeraNorm = normalizarAAscii(primeraPalabra);
+        const expectedNorm = normalizarAAscii(expectedAnswer);
+        return primeraNorm === expectedNorm;
+    },
+    async getRandomVerse(iaDir) {
+        const piedraDir = join(iaDir, 'piedra_fundamental');
+        const files = (await readdir(piedraDir)).filter(f => f.endsWith('.usfm'));
+        const chosenFile = files[Math.floor(Math.random() * files.length)];
+        const content = await readFile(join(piedraDir, chosenFile), 'utf-8');
+        const verses = content.split('\\v ').slice(1);
+        const verse = verses[Math.floor(Math.random() * verses.length)].trim();
+        const verseNum = verse.match(/^\d+/)?.[0] || '?';
+        const ref = `${chosenFile.replace('.usfm', '').replace('marcos-', 'Marcos ')}:${verseNum}`;
+        return { verse: verse.split('\\')[0].trim(), ref };
+    },
+    async getRandomCristologicaQuestion(iaDir) {
+        const cristologicaPath = join(iaDir, 'verificacion_cristologica.json');
+        const data = JSON.parse(await readFile(cristologicaPath, 'utf-8'));
+        const q = data.preguntas[Math.floor(Math.random() * data.preguntas.length)];
+        return {
+            pregunta: q.pregunta,
+            respuesta_esperada: q.respuesta_esperada,
+            referencia: q.referencia,
+        };
+    }
+};

package/dist/tasks/ai.d.ts

@@ -0,0 +1,3 @@
+export declare function runAiFramework(outputFile?: string): Promise<void>;
+export declare function runAiVerifyQuestion(): Promise<void>;
+export declare function runAiVerifyAnswer(answer: string): Promise<void>;

package/dist/tasks/ai.js

@@ -0,0 +1,96 @@
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { aiVerifyCore } from './ai-verify-core.js';
+import { findIaDir } from '@pasosdejesus/m/dist/tasks/util.js';
+import { createTranslator } from '@pasosdejesus/m/dist/i18n/createTranslator.js';
+import { detectLocale } from '@pasosdejesus/m/dist/util/locale.js';
+import commonCli from '@pasosdejesus/m/dist/i18n/common-cli.js';
+import { info, problem, success } from '@pasosdejesus/m/dist/util/colors.js';
+const aiT = createTranslator(detectLocale(), {
+    en: {
+        'ai.framework.no_files': 'No alignment files found in directory ia/. Create at least one file alineacion_*.md.',
+        'ai.framework.written': 'Alignment manifest written in: {{0}}',
+        'ai.verify.no_ia_dir': 'Directory ia/ not found in current project.',
+        'ai.verify.passed': 'Verification passed.',
+        'ai.verify.failed': 'Verification failure. Expected: {{0}}, Obtained: {{1}}.',
+    },
+    es: {
+        'ai.framework.no_files': 'No se encontraron archivos de alineación en el directorio ia/. Crea al menos un archivo alineacion_*.md.',
+        'ai.framework.written': 'Manifiesto de alineación escrito en: {{0}}',
+        'ai.verify.no_ia_dir': 'No se encontró el directorio ia/ en el proyecto actual.',
+        'ai.verify.passed': 'Verificación superada.',
+        'ai.verify.failed': 'Fallo de verificación. Esperado: {{0}}, Obtenido: {{1}}.',
+    },
+}, commonCli);
+export async function runAiFramework(outputFile) {
+    const iaDir = await findIaDir();
+    if (!iaDir) {
+        problem(aiT('ai.framework.no_files'));
+        return;
+    }
+    const alignmentFiles = (await readdir(iaDir))
+        .filter(f => f.startsWith('alineacion_') && f.endsWith('.md'));
+    if (alignmentFiles.length === 0) {
+        problem(aiT('ai.framework.no_files'));
+        return;
+    }
+    const chosen = alignmentFiles[Math.floor(Math.random() * alignmentFiles.length)];
+    const content = await readFile(join(iaDir, chosen), 'utf-8');
+    if (outputFile) {
+        await writeFile(outputFile, content);
+        success(aiT('ai.framework.written', outputFile));
+    }
+    else {
+        console.log(content);
+        const { setClipboard } = await import('@pasosdejesus/m/dist/tasks/edit.js');
+        await setClipboard(content);
+        success(`📋 Manifiesto copiado al portapapeles (${Math.round(content.length / 1024)}KB)`);
+    }
+}
+export async function runAiVerifyQuestion() {
+    const iaDir = await findIaDir();
+    if (!iaDir) {
+        problem(aiT('ai.verify.no_ia_dir'));
+        return;
+    }
+    const { question, expectedAnswer, reference } = await aiVerifyCore.generateQuestion(iaDir);
+    const qaPath = join(process.cwd(), 'most-recent-question.json');
+    await writeFile(qaPath, JSON.stringify({ question, expectedAnswer, reference }, null, 2));
+    success(`Pregunta guardada en ${qaPath}`);
+    info('=== Verificación de Alineación ===');
+    console.log(`\n${question}`);
+    console.log(`\nReferencia: ${reference}`);
+    console.log(`\nPara responder ejecuta: bin/m ai:verify:answer "SÍ, ..."\n`);
+    const { setClipboard } = await import('@pasosdejesus/m/dist/tasks/edit.js');
+    await setClipboard(question);
+    success('📋 Pregunta copiada al portapapeles');
+}
+export async function runAiVerifyAnswer(answer) {
+    const qaPath = join(process.cwd(), 'most-recent-question.json');
+    let qa;
+    try {
+        qa = JSON.parse(await readFile(qaPath, 'utf-8'));
+    }
+    catch {
+        problem('No se encontró most-recent-question.json. Ejecuta primero bin/m ai:verify:question');
+        process.exit(1);
+    }
+    if (!answer) {
+        problem('Debes proporcionar una respuesta como argumento');
+        process.exit(1);
+    }
+    const passed = aiVerifyCore.evaluateAnswer(answer, qa.expectedAnswer);
+    if (passed) {
+        success(aiT('ai.verify.passed'));
+    }
+    else {
+        const primeraPalabra = answer.split(/\s+/)[0].toUpperCase();
+        problem(aiT('ai.verify.failed', qa.expectedAnswer, primeraPalabra));
+        console.log(`\nExplicación proporcionada:\n${answer}\n`);
+        process.exit(1);
+    }
+    try {
+        await writeFile(qaPath, '');
+    }
+    catch { }
+}

package/dist/tasks/credentials.d.ts

@@ -0,0 +1,4 @@
+declare function deploymentsExist(): boolean;
+declare function hasAdminKey(): boolean;
+export declare function runCredentials(args: string[]): Promise<void>;
+export { deploymentsExist, hasAdminKey };