@arcadialdev/arcality 3.0.4 → 4.0.1

package/scripts/generate.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { analyzeCodebase } from '../src/services/codebaseAnalyzer.mjs';
+import { loadProjectConfig, getYamlOutputDir } from '../src/configManager.mjs';
+import { generateMissionsForRoute } from '../src/services/missionGenerator.mjs';
+import { saveGeneratedMissions } from '../src/services/generatedMissionStore.mjs';
+import { loadGenerationContext, resolveRouteGuidance } from '../src/services/generationContext.mjs';
+
+function parseArgs(rawArgs) {
+    const options = {
+        count: null,
+        page: [],
+        prompt: '',
+        dryRun: false,
+        outputDir: null,
+        debug: false
+    };
+
+    for (let i = 0; i < rawArgs.length; i++) {
+        const token = rawArgs[i];
+        if (token === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        if (token === '--debug') {
+            options.debug = true;
+            continue;
+        }
+        if (token.startsWith('--count=')) {
+            options.count = Number(token.split('=').slice(1).join('='));
+            continue;
+        }
+        if (token === '--count' && rawArgs[i + 1]) {
+            options.count = Number(rawArgs[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (token.startsWith('--page=')) {
+            options.page = token.split('=').slice(1).join('=').split(',').map(v => v.trim()).filter(Boolean);
+            continue;
+        }
+        if (token === '--page' && rawArgs[i + 1]) {
+            options.page = rawArgs[i + 1].split(',').map(v => v.trim()).filter(Boolean);
+            i += 1;
+            continue;
+        }
+        if (token.startsWith('--prompt=')) {
+            options.prompt = token.split('=').slice(1).join('=').trim();
+            continue;
+        }
+        if (token === '--prompt' && rawArgs[i + 1]) {
+            options.prompt = rawArgs[i + 1].trim();
+            i += 1;
+            continue;
+        }
+        if (token.startsWith('--output-dir=')) {
+            options.outputDir = token.split('=').slice(1).join('=').trim();
+            continue;
+        }
+        if (token === '--output-dir' && rawArgs[i + 1]) {
+            options.outputDir = rawArgs[i + 1].trim();
+            i += 1;
+            continue;
+        }
+    }
+
+    return options;
+}
+
+function matchesPageFilters(routeEntry, filters) {
+    if (!filters || filters.length === 0) return true;
+    const haystacks = [
+        routeEntry.pagePath.toLowerCase(),
+        routeEntry.route.toLowerCase()
+    ];
+    return filters.some(filter => {
+        const normalized = filter.toLowerCase();
+        return haystacks.some(value => value === normalized || value.includes(normalized));
+    });
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isLikelyUuidFilter(filter) {
+    return UUID_RE.test(String(filter || '').trim());
+}
+
+function formatRouteExamples(routes, maxItems = 3) {
+    return routes
+        .slice(0, maxItems)
+        .map(entry => `${entry.route} -> ${entry.pagePath}`)
+        .join('\n- ');
+}
+
+
+function limitEntries(entries, count) {
+    if (!Number.isFinite(count) || count <= 0) return entries;
+    return entries.slice(0, Math.floor(count));
+}
+
+function limitMissions(missions, count) {
+    if (!Number.isFinite(count) || count <= 0) return missions;
+    return missions.slice(0, Math.floor(count));
+}
+
+function printSummary(analysis, selectedRoutes, options, generationContext) {
+    console.log('\nArcality Generate - Discovery Summary');
+    console.log(`Project: ${analysis.projectName}`);
+    console.log(`Framework: ${analysis.framework}`);
+    console.log(`Routes detected: ${analysis.routeCount}`);
+    console.log(`Routes selected: ${selectedRoutes.length}`);
+    console.log(`Mission cap: ${Number.isFinite(options.count) && options.count > 0 ? Math.floor(options.count) : 'auto'}`);
+    console.log(`Output target: ${options.outputTarget}`);
+    console.log(`Mode: ${options.dryRun ? 'dry-run' : 'write-yaml'}`);
+    console.log(`QA context: ${generationContext.qaContext.exists ? generationContext.qaContext.status : 'missing'}`);
+    console.log(`Feasibility guidance: ${generationContext.feasibility.exists ? 'loaded' : 'missing'}`);
+
+    if (options.prompt) {
+        console.log(`Prompt focus: ${options.prompt}`);
+    }
+
+    if (analysis.warnings.length > 0) {
+        console.log('\nWarnings:');
+        for (const warning of analysis.warnings) {
+            console.log(`- ${warning}`);
+        }
+    }
+
+    if (selectedRoutes.length === 0) {
+        console.log('\nNo candidate routes matched the provided filters.');
+        const uuidFilters = (options.page || []).filter(isLikelyUuidFilter);
+        if (uuidFilters.length > 0) {
+            console.log('Tip: the current --page filter only matches route fragments or page file paths, not backend page IDs or UUIDs.');
+        }
+        if ((options.page || []).length > 0 && analysis.routes.length > 0) {
+            console.log('Try values such as a route (`/checkout`) or a page path fragment (`app/checkout/page.tsx`).');
+            console.log(`Examples:\n- ${formatRouteExamples(analysis.routes)}`);
+        }
+        return;
+    }
+
+    console.log('\nCandidate routes:');
+    selectedRoutes.forEach((entry, index) => {
+        const guidance = resolveRouteGuidance(entry, generationContext);
+        console.log(`${index + 1}. ${entry.route} -> ${entry.pagePath} [${entry.routerKind}]`);
+        if (options.debug) {
+            console.log(`   name: ${entry.name}`);
+            console.log(`   tags: ${entry.tags.join(', ')}`);
+            console.log(`   signals: ${Object.entries(entry.signals || {}).filter(([, value]) => value === true).map(([key]) => key).join(', ') || 'none'}`);
+            console.log(`   route_params: ${(entry.routeParams || []).map(param => `${param.name}:${param.kind}`).join(', ') || 'none'}`);
+            console.log(`   route_example: ${entry.routeExamplePath || entry.route}`);
+            console.log(`   matched_rules: ${guidance.matchedRules.map(rule => rule.text).join(' | ') || 'none'}`);
+            console.log(`   feasibility_hints: ${guidance.feasibilityHints.join(' | ') || 'none'}`);
+            console.log(`   expected_result: ${entry.expectedResult}`);
+        }
+    });
+}
+
+function printPhaseNotice(options) {
+    if (options.dryRun) {
+        console.log('\nNo files were written because --dry-run is active.');
+        return;
+    }
+}
+
+function printWriteSummary(summary, options) {
+    console.log('\nGeneration result:');
+    console.log(`- Requested missions: ${summary.total_requested}`);
+    console.log(`- Created: ${summary.created_count}`);
+    console.log(`- Skipped: ${summary.skipped_count}`);
+
+    if (summary.created.length > 0) {
+        console.log('\nCreated files:');
+        for (const item of summary.created) {
+            console.log(`- ${item.filePath}`);
+        }
+    }
+
+    if (summary.skipped.length > 0 && options.debug) {
+        console.log('\nSkipped entries:');
+        for (const item of summary.skipped) {
+            console.log(`- ${item.name} (${item.page_path}) -> ${item.reason}`);
+        }
+    }
+}
+
+function resolveOutputTarget(projectRoot, explicitOutputDir) {
+    if (explicitOutputDir) {
+        return path.resolve(projectRoot, explicitOutputDir);
+    }
+
+    const config = loadProjectConfig(projectRoot);
+    if (config) {
+        return path.join(getYamlOutputDir(config, projectRoot), 'generated');
+    }
+
+    return path.join(projectRoot, '.arcality', 'generated');
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+    const projectRoot = process.cwd();
+    options.outputTarget = resolveOutputTarget(projectRoot, options.outputDir);
+    const projectConfig = loadProjectConfig(projectRoot);
+
+    const analysis = analyzeCodebase(projectRoot, {
+        baseUrl: projectConfig?.project?.baseUrl || ''
+    });
+    const generationContext = loadGenerationContext(projectRoot);
+    const filtered = analysis.routes.filter(route => matchesPageFilters(route, options.page));
+    const selectedRoutes = limitEntries(filtered, options.page.length > 0 ? null : Math.max(filtered.length, 1));
+
+    printSummary(analysis, selectedRoutes, options, generationContext);
+
+    const missions = limitMissions(
+        selectedRoutes.flatMap(route => generateMissionsForRoute(route, {
+            ...options,
+            routeGuidance: resolveRouteGuidance(route, generationContext)
+        })),
+        options.count
+    );
+    const summary = saveGeneratedMissions({
+        projectRoot,
+        targetDir: options.outputTarget,
+        missions,
+        dryRun: options.dryRun
+    });
+
+    printWriteSummary(summary, options);
+    printPhaseNotice(options);
+}
+
+main().catch(err => {
+    console.error(`\n[generate] ${err.message}`);
+    process.exit(1);
+});