@revoengine/cli 1.0.6 → 1.0.8

package/dist/src/commands/component.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { ApiError, PermissionDeniedError } from "../client.js";
 import { hashComponentSource, hashStable, readComponentLock, sanitizeComponentSource, upsertComponentLockEntry, } from "../component-lock.js";
 import { buildSandboxDebugStreamUrl, buildSandboxDebugUrl, extractSandboxEndpoint, resolveProjectRoot, resolveProjectWorkspace, } from "../project.js";
@@ -297,6 +298,82 @@ function findComponentManifestsById(cwd, componentId) {
         return getComponentIdFromPath(path.dirname(manifestPath)).includes(componentId);
     });
 }
+function isRelativeInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function readGitChangedPaths(cwd, workspaceRoot, base) {
+    const rootRelativePath = path.relative(cwd, workspaceRoot) || 'Components';
+    const args = base.includes('..')
+        ? ['diff', '--name-only', base, '--', rootRelativePath]
+        : ['diff', '--name-only', `${base}...HEAD`, '--', rootRelativePath];
+    try {
+        return execFileSync('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        })
+            .split(/\r?\n/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to resolve changed Revo components from git base "${base}": ${message}`);
+    }
+}
+function componentIdFromChangedPath(changedPath) {
+    const segments = changedPath.split(/[\\/]+/);
+    const componentsIndex = segments.indexOf('Components');
+    if (componentsIndex < 0) {
+        return '';
+    }
+    for (const segment of segments.slice(componentsIndex + 1)) {
+        const componentId = getComponentIdFromPath(segment);
+        if (componentId !== segment) {
+            return componentId;
+        }
+    }
+    return '';
+}
+function resolveChangedComponentScope(context) {
+    const enabled = readBoolFlag(context.args, ['changed', 'changed-only']);
+    const base = readFlag(context.args, ['base', 'git-base']) || 'origin/develop';
+    if (!enabled) {
+        return {
+            enabled,
+            base,
+            componentIds: new Set(),
+        };
+    }
+    const workspaceRoot = getWorkspaceRoot(context.cwd);
+    const changedPaths = readGitChangedPaths(context.cwd, workspaceRoot, base);
+    const manifestPaths = getComponentManifestPaths(workspaceRoot);
+    const componentIds = new Set();
+    for (const changedPath of changedPaths) {
+        const absoluteChangedPath = path.resolve(context.cwd, changedPath);
+        for (const manifestPath of manifestPaths) {
+            const componentDir = path.dirname(manifestPath);
+            if (!isRelativeInside(componentDir, absoluteChangedPath)) {
+                continue;
+            }
+            const component = readWorkspaceComponentSafe(manifestPath);
+            const componentId = component ? componentIdOf(component) : '';
+            if (componentId) {
+                componentIds.add(componentId);
+            }
+        }
+        const deletedComponentId = componentIdFromChangedPath(changedPath);
+        if (deletedComponentId) {
+            componentIds.add(deletedComponentId);
+        }
+    }
+    return {
+        enabled,
+        base,
+        componentIds,
+    };
+}
 function unwrapList(value) {
     if (Array.isArray(value)) {
         return value;
@@ -725,6 +802,9 @@ async function pushSingleComponent(context, manifestPath) {
         throw new Error(`Missing component name in ${manifestPath}.`);
     }
     const elements = (component.elements || []).map((element) => ({
+        ...(typeof element.componentElementId === 'string' && element.componentElementId
+            ? { componentElementId: element.componentElementId }
+            : {}),
         key: element.key,
         desc: element.desc,
         details: element.details || '',
@@ -785,6 +865,13 @@ async function pushSingleComponent(context, manifestPath) {
                 targetPath,
                 reason: 'no changes',
             };
+            try {
+                const remote = unwrapComponent(await client.getComponent(componentId));
+                upsertLockFromRemote(context.cwd, remote, targetPath);
+            }
+            catch {
+                upsertLockFromRemote(context.cwd, component, targetPath);
+            }
             printSyncStatus(println, {
                 status: 'Skipped',
                 direction: 'push',
@@ -850,11 +937,22 @@ async function pushSingleComponent(context, manifestPath) {
 async function pushAllComponents(context, options) {
     const { cwd, println } = context;
     const root = getWorkspaceRoot(cwd);
-    const manifests = getComponentManifestPaths(root);
+    let manifests = getComponentManifestPaths(root);
     if (manifests.length === 0) {
         println(`No component.json files found in ${path.relative(cwd, root) || 'Components'}.`);
         return [];
     }
+    if (options.scope?.enabled) {
+        manifests = manifests.filter((manifestPath) => {
+            const component = readWorkspaceComponentSafe(manifestPath);
+            const componentId = component ? componentIdOf(component) : '';
+            return componentId && options.scope?.componentIds.has(componentId);
+        });
+        if (manifests.length === 0) {
+            println(`No changed Revo components found for git base ${options.scope.base}.`);
+            return [];
+        }
+    }
     await confirmBulkAction(context, 'push', manifests.length, options.force || options.yes);
     const startedAt = Date.now();
     const results = [];
@@ -867,7 +965,7 @@ async function pushAllComponents(context, options) {
     printSummary(context.println, 'Deployed', results, Date.now() - startedAt);
     return results;
 }
-async function buildComponentPlan(context) {
+async function buildComponentPlan(context, scope = { enabled: false, base: '', componentIds: new Set() }) {
     const projectRoot = getProjectRoot(context.cwd);
     const lock = readComponentLock(projectRoot);
     const root = getWorkspaceRoot(context.cwd);
@@ -947,6 +1045,7 @@ async function buildComponentPlan(context) {
             status = 'conflict';
             reason = 'local and remote changed since lock';
         }
+        const inScope = !scope.enabled || scope.componentIds.has(componentId);
         return {
             componentId,
             componentName,
@@ -958,12 +1057,20 @@ async function buildComponentPlan(context) {
             remoteHash,
             remoteVersion: remote ? componentVersion(remote.component) : lockEntry?.remoteVersion ?? null,
             reason,
+            ...(scope.enabled ? { inScope } : {}),
         };
     });
     return {
         schemaVersion: 1,
         generatedAt: new Date().toISOString(),
         workspaceRoot: path.relative(context.cwd, root) || 'Components',
+        ...(scope.enabled ? {
+            scope: {
+                mode: 'changed',
+                base: scope.base,
+                componentIds: [...scope.componentIds].sort(),
+            },
+        } : {}),
         counts: items.reduce((counts, item) => {
             counts[item.status] += 1;
             return counts;
@@ -1047,6 +1154,47 @@ function buildDebugElements(component) {
         };
     });
 }
+function resolveElementSourcePath(manifestPath, component, element) {
+    const componentDir = path.dirname(manifestPath);
+    const detailDirs = [
+        path.join(componentDir, 'elements'),
+        path.join(componentDir, 'details'),
+    ].filter((dir, index, list) => list.indexOf(dir) === index);
+    const extension = componentTypeToExtension(normalizeComponentType(component));
+    const fileName = `${element.order}_${element.key}.${extension}`;
+    for (const detailDir of detailDirs) {
+        const preferredPath = path.join(detailDir, fileName);
+        if (fs.existsSync(preferredPath)) {
+            return preferredPath;
+        }
+        if (fs.existsSync(detailDir)) {
+            const match = fs.readdirSync(detailDir).find((entry) => entry.startsWith(`${element.order}_${element.key}.`));
+            if (match) {
+                return path.join(detailDir, match);
+            }
+        }
+    }
+    return null;
+}
+function buildDebugSourceComponent(role, manifestPath, component) {
+    return {
+        role,
+        componentId: component.componentId || component.id || '',
+        componentName: component.name || '',
+        type: normalizeComponentType(component),
+        manifestPath,
+        elements: [...(component.elements || [])].sort((left, right) => left.order - right.order).map((element) => {
+            const sourcePath = resolveElementSourcePath(manifestPath, component, element);
+            const details = element.details || '';
+            return {
+                key: element.key,
+                order: element.order,
+                sourcePath,
+                bytes: Buffer.byteLength(details, 'utf8'),
+            };
+        }),
+    };
+}
 function isDebugLibraryType(type) {
     return type === 'CODE_TS_LIB' || type === 'CODE_JS_LIB';
 }
@@ -1086,19 +1234,28 @@ function buildDebugPayload(cwd, component, input) {
 }
 function collectDebugExtraLibs(cwd, currentComponentId) {
     return getComponentManifestPaths(getWorkspaceRoot(cwd))
-        .map((manifestPath) => readWorkspaceComponentSafe(manifestPath))
-        .filter((component) => Boolean(component))
-        .filter((component) => {
+        .map((manifestPath) => {
+        const component = readWorkspaceComponentSafe(manifestPath);
+        return component ? { manifestPath, component } : null;
+    })
+        .filter((entry) => Boolean(entry))
+        .filter(({ component }) => {
         const type = normalizeComponentType(component);
         const componentId = component.componentId || component.id || '';
         return isDebugLibraryType(type) && componentId !== currentComponentId && Boolean(component.name);
     })
-        .map((component) => ({
-        name: component.name,
-        type: normalizeComponentType(component),
-        elements: buildDebugElements(component),
+        .map(({ manifestPath, component }) => ({
+        payload: {
+            name: component.name,
+            type: normalizeComponentType(component),
+            elements: buildDebugElements(component),
+        },
+        source: buildDebugSourceComponent('extraLib', manifestPath, component),
     }));
 }
+function writeRawDebugRequestDump(options) {
+    process.stderr.write(`[debug-request] ${JSON.stringify(options, null, 2)}\n`);
+}
 function formatProcessLog(log) {
     if (!log || typeof log !== 'object' || Array.isArray(log)) {
         return String(log ?? '');
@@ -1158,21 +1315,34 @@ async function debugSingleComponent(context, componentId) {
     const memory = parseDebugNumber(context.args, ['memory', 'm'], 128, 1024, 'Memory');
     const stream = readBoolFlag(context.args, ['stream']);
     const includeExtraLibs = !readBoolFlag(context.args, ['no-extra-libs']);
+    const rawDebug = readBoolFlag(context.args, ['raw-debug', 'debug-raw', 'debug-payload']);
     const profile = await context.client.me();
     const sandboxEndpoint = extractSandboxEndpoint(profile);
     if (!sandboxEndpoint) {
         throw new Error('Authenticated profile did not include `endpoints.sandbox`, so component debug cannot run.');
     }
+    const extraLibs = includeExtraLibs ? collectDebugExtraLibs(context.cwd, componentKey) : [];
     const payload = buildDebugPayload(context.cwd, component, {
         inputs,
         timeout,
         memory,
-        extraLibs: includeExtraLibs ? collectDebugExtraLibs(context.cwd, componentKey) : [],
+        extraLibs: extraLibs.map((entry) => entry.payload),
     });
+    const endpoint = stream ? buildSandboxDebugStreamUrl(sandboxEndpoint) : buildSandboxDebugUrl(sandboxEndpoint);
+    if (rawDebug) {
+        writeRawDebugRequestDump({
+            endpoint,
+            cwd: context.cwd,
+            workspaceRoot: getWorkspaceRoot(context.cwd),
+            selected: buildDebugSourceComponent('selected', manifestPath, component),
+            extraLibs: extraLibs.map((entry) => entry.source),
+            payload,
+        });
+    }
     if (stream) {
         let result;
         let done = false;
-        for await (const event of context.client.debugComponentStream(buildSandboxDebugStreamUrl(sandboxEndpoint), payload)) {
+        for await (const event of context.client.debugComponentStream(endpoint, payload)) {
             if (event.event === 'log') {
                 process.stderr.write(`${formatProcessLog(event.data)}\n`);
             }
@@ -1193,7 +1363,7 @@ async function debugSingleComponent(context, componentId) {
         context.print(extractResultPayload(result));
         return;
     }
-    const response = await context.client.debugComponent(buildSandboxDebugUrl(sandboxEndpoint), payload);
+    const response = await context.client.debugComponent(endpoint, payload);
     writeDebugOutputFile(context.cwd, response);
     context.print(extractResultPayload(response));
 }
@@ -1207,16 +1377,17 @@ export async function handleComponentCommand(context) {
     const stale = readBoolFlag(args, ['stale', 's']);
     const json = readBoolFlag(args, ['json']);
     const strict = readBoolFlag(args, ['strict']);
+    const changedScope = resolveChangedComponentScope(context);
     if (subcommand === 'pull-all') {
         await pullAllComponents(context, { force, stale, yes });
         return;
     }
     if (subcommand === 'push-all') {
-        await pushAllComponents(context, { force, yes });
+        await pushAllComponents(context, { force, yes, scope: changedScope });
         return;
     }
     if (subcommand === 'plan') {
-        const plan = await buildComponentPlan(context);
+        const plan = await buildComponentPlan(context, changedScope);
         if (json) {
             context.print(plan);
         }
@@ -1224,10 +1395,11 @@ export async function handleComponentCommand(context) {
             printPlan(context, plan);
         }
         if (strict) {
-            const blocking = plan.items.filter((item) => (item.status === 'conflict'
-                || item.status === 'missing-lock'
-                || item.status === 'remote-changed'
-                || item.status === 'safe-update'));
+            const blocking = plan.items.filter((item) => ((!changedScope.enabled || item.inScope)
+                && (item.status === 'conflict'
+                    || item.status === 'missing-lock'
+                    || item.status === 'remote-changed'
+                    || item.status === 'safe-update')));
             if (blocking.length > 0) {
                 throw new Error(`Component plan is not safe: ${blocking.length} blocking item(s).`);
             }
@@ -1260,7 +1432,7 @@ export async function handleComponentCommand(context) {
             throw new Error('Provide --id <componentId> or --all.');
         }
         if (all) {
-            await pushAllComponents(context, { force, yes });
+            await pushAllComponents(context, { force, yes, scope: changedScope });
             return;
         }
         const manifests = targets.flatMap((componentId) => findComponentManifestsById(context.cwd, componentId));

package/dist/src/types.d.ts

@@ -13,6 +13,7 @@ export type CommandContext = {
     error: (message: string) => void;
 };
 export type ComponentElementRecord = {
+    componentElementId?: string;
     key: string;
     desc?: string;
     details?: string;

package/dist/src/ui.js

@@ -108,12 +108,12 @@ function renderCommandCatalog() {
         commandRow('revo endpoints', 'List available API endpoints'),
         '',
         paintHeader('Components'),
-        commandRow('revo component plan --all [--json] [--strict]', 'Preview local/remote sync status'),
+        commandRow('revo component plan --all [--json] [--strict] [--changed --base <ref>]', 'Preview local/remote sync status'),
         commandRow('revo component pull <componentId...> [--force]', 'Pull one or more components safely'),
         commandRow('revo component pull --all [--yes] [--force]', 'Pull every available component safely'),
         commandRow('revo component push <componentId...>', 'Push one or more local components'),
-        commandRow('revo component push --all [--yes] [--force]', 'Push every local component with lock checks'),
-        commandRow('revo component debug <componentId> [BODY] [--stream]', 'Debug one local component against sandbox'),
+        commandRow('revo component push --all [--yes] [--force] [--changed --base <ref>]', 'Push local components with lock checks'),
+        commandRow('revo component debug <componentId> [BODY] [--stream] [--raw-debug]', 'Debug one local component against sandbox'),
         '',
         paintHeader('Low-Level'),
         commandRow('revo search <CODE|SIMPLE> <term>', 'Search code references or all platform content'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revoengine/cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "CLI package for the RevoEngine Platform API",
   "type": "module",
   "main": "dist/src/index.js",