scene-capability-engine 3.6.60 → 3.6.62

package/lib/commands/studio.js

@@ -921,273 +921,6 @@ function extractEventArrayFromPayload(payload) {
   return [payload];
 }
 
-async function readOpenHandsEventsFile(openhandsEventsPath, fileSystem = fs) {
-  const normalizedPath = normalizeString(openhandsEventsPath);
-  if (!normalizedPath) {
-    return [];
-  }
-  const exists = await fileSystem.pathExists(normalizedPath);
-  if (!exists) {
-    throw new Error(`OpenHands events file not found: ${normalizedPath}`);
-  }
-
-  const content = await fileSystem.readFile(normalizedPath, 'utf8');
-  const trimmed = `${content || ''}`.trim();
-  if (!trimmed) {
-    return [];
-  }
-
-  try {
-    const parsed = JSON.parse(trimmed);
-    return extractEventArrayFromPayload(parsed);
-  } catch (_error) {
-    const lines = trimmed
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter(Boolean);
-    const parsedLines = [];
-    for (const line of lines) {
-      try {
-        parsedLines.push(JSON.parse(line));
-      } catch (_innerError) {
-        // Skip malformed JSONL lines to keep ingestion robust.
-      }
-    }
-    return parsedLines;
-  }
-}
-
-function normalizeOpenHandsEventRecord(rawEvent, index, jobId) {
-  const raw = rawEvent && typeof rawEvent === 'object'
-    ? rawEvent
-    : { value: rawEvent };
-  const eventId = pickFirstString([
-    raw.event_id,
-    raw.eventId,
-    raw.id,
-    raw.uuid
-  ]) || `oh-evt-${index + 1}`;
-  const eventType = pickFirstString([
-    raw.event_type,
-    raw.eventType,
-    raw.type,
-    raw.kind,
-    raw.action
-  ]) || 'unknown';
-  const timestamp = pickFirstString([
-    raw.timestamp,
-    raw.time,
-    raw.created_at,
-    raw.createdAt,
-    raw.ts
-  ]) || nowIso();
-  return {
-    api_version: STUDIO_EVENT_API_VERSION,
-    event_id: eventId,
-    job_id: jobId,
-    event_type: `openhands.${eventType}`,
-    timestamp,
-    metadata: {
-      source: 'openhands',
-      raw
-    }
-  };
-}
-
-function tryParseJsonText(value) {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (!(trimmed.startsWith('{') || trimmed.startsWith('['))) {
-    return null;
-  }
-  try {
-    return JSON.parse(trimmed);
-  } catch (_error) {
-    return null;
-  }
-}
-
-function stringifyCompact(value) {
-  if (value == null) {
-    return '';
-  }
-  if (typeof value === 'string') {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch (_error) {
-    return `${value}`;
-  }
-}
-
-function extractOpenHandsCommandCandidates(raw = {}) {
-  const command = pickFirstString([
-    raw.command,
-    raw.cmd,
-    raw.input && raw.input.command,
-    raw.action && raw.action.command,
-    raw.observation && raw.observation.command,
-    raw.tool_input && raw.tool_input.command
-  ]);
-
-  const toolName = pickFirstString([
-    raw.tool_name,
-    raw.toolName,
-    raw.tool && raw.tool.name,
-    raw.name
-  ]);
-  const toolArgs = raw.arguments || raw.tool_input || raw.input || null;
-
-  const cmd = command || (toolName
-    ? `tool:${toolName}${toolArgs ? ` ${stringifyCompact(toolArgs)}` : ''}`
-    : '');
-
-  return {
-    cmd,
-    exit_code: pickFirstNumber([
-      raw.exit_code,
-      raw.exitCode,
-      raw.result && (raw.result.exit_code ?? raw.result.exitCode)
-    ]),
-    stdout: pickFirstString([
-      raw.stdout,
-      raw.output,
-      raw.result && raw.result.stdout,
-      raw.observation && raw.observation.stdout
-    ]),
-    stderr: pickFirstString([
-      raw.stderr,
-      raw.result && raw.result.stderr,
-      raw.error && raw.error.message,
-      typeof raw.error === 'string' ? raw.error : ''
-    ]),
-    log_path: pickFirstString([
-      raw.log_path,
-      raw.logPath,
-      raw.log && raw.log.path
-    ])
-  };
-}
-
-function collectOpenHandsFileChangesFromRaw(raw = {}) {
-  const changes = [];
-  const addPath = (pathValue, lineValue, diffRefValue = '') => {
-    const pathRef = normalizeString(pathValue);
-    if (!pathRef) {
-      return;
-    }
-    const line = Number.parseInt(`${lineValue != null ? lineValue : 1}`, 10);
-    const normalizedLine = Number.isFinite(line) && line > 0 ? line : 1;
-    const diffRef = normalizeString(diffRefValue) || `${pathRef}:${normalizedLine}`;
-    changes.push({
-      path: pathRef,
-      line: normalizedLine,
-      diffRef
-    });
-  };
-
-  if (typeof raw.path === 'string') {
-    addPath(raw.path, raw.line || raw.line_number, raw.diff_ref);
-  }
-  if (raw.file && typeof raw.file === 'object') {
-    addPath(raw.file.path || raw.file.name, raw.file.line || raw.file.line_number, raw.file.diffRef || raw.file.diff_ref);
-  }
-
-  const arrayKeys = ['files', 'changed_files', 'modified_files', 'created_files', 'deleted_files'];
-  for (const key of arrayKeys) {
-    const values = Array.isArray(raw[key]) ? raw[key] : [];
-    for (const value of values) {
-      if (typeof value === 'string') {
-        addPath(value, 1);
-      } else if (value && typeof value === 'object') {
-        addPath(value.path || value.file || value.name, value.line || value.line_number, value.diffRef || value.diff_ref);
-      }
-    }
-  }
-
-  const patchText = pickFirstString([raw.patch, raw.diff]);
-  if (patchText) {
-    const parsedJson = tryParseJsonText(patchText);
-    if (parsedJson && typeof parsedJson === 'object') {
-      const nested = collectOpenHandsFileChangesFromRaw(parsedJson);
-      changes.push(...nested);
-    } else {
-      const lines = patchText.split(/\r?\n/);
-      for (const line of lines) {
-        const match = line.match(/^\+\+\+\s+b\/(.+)$/);
-        if (match && match[1]) {
-          addPath(match[1], 1);
-        }
-      }
-    }
-  }
-
-  return changes;
-}
-
-function mapOpenHandsEventsToTaskSignals(openhandsEvents = [], context = {}) {
-  const normalizedEvents = openhandsEvents.map((item, index) =>
-    normalizeOpenHandsEventRecord(item, index, context.jobId)
-  );
-
-  const commands = [];
-  const fileChanges = [];
-  const errors = [];
-  const evidence = [];
-
-  for (const event of normalizedEvents) {
-    const raw = event && event.metadata ? event.metadata.raw || {} : {};
-    const commandCandidate = extractOpenHandsCommandCandidates(raw);
-    if (commandCandidate.cmd || commandCandidate.stdout || commandCandidate.stderr || commandCandidate.exit_code != null) {
-      commands.push(commandCandidate);
-    }
-
-    fileChanges.push(...collectOpenHandsFileChangesFromRaw(raw));
-
-    const eventType = normalizeString(event.event_type).toLowerCase();
-    const failedByType = eventType.includes('error') || eventType.includes('fail');
-    const failedByExit = commandCandidate.exit_code != null && Number(commandCandidate.exit_code) !== 0;
-    const failedByStderr = commandCandidate.stderr.length > 0 && !commandCandidate.stdout;
-    if (failedByType || failedByExit || failedByStderr) {
-      const message = pickFirstString([
-        raw.message,
-        raw.error && raw.error.message,
-        typeof raw.error === 'string' ? raw.error : '',
-        failedByExit ? `OpenHands command failed (exit ${commandCandidate.exit_code})` : '',
-        'OpenHands event indicates failure'
-      ]);
-      errors.push({
-        message,
-        step_id: event.event_type,
-        cmd: commandCandidate.cmd,
-        exit_code: commandCandidate.exit_code,
-        stderr: commandCandidate.stderr,
-        stdout: commandCandidate.stdout
-      });
-    }
-
-    evidence.push({
-      type: 'openhands-event',
-      ref: event.event_id,
-      detail: event.event_type
-    });
-  }
-
-  return {
-    event: normalizedEvents,
-    commands: normalizeTaskCommands(commands),
-    file_changes: normalizeTaskFileChanges(fileChanges),
-    errors: normalizeTaskErrors(errors),
-    evidence: normalizeTaskEvidence(evidence)
-  };
-}
-
 function extractCommandsFromStageMetadata(stageMetadata = {}) {
   const gateSteps = Array.isArray(stageMetadata && stageMetadata.gate_steps)
     ? stageMetadata.gate_steps
@@ -2919,21 +2652,7 @@ async function runStudioEventsCommand(options = {}, dependencies = {}) {
 
   const limit = normalizePositiveInteger(options.limit, 50);
   const job = await loadJob(paths, jobId, fileSystem);
-  const openhandsEventsPath = normalizeString(options.openhandsEvents);
-  let sourceStream = 'studio';
   let events = await readStudioEvents(paths, jobId, { limit }, fileSystem);
-  let openhandsSignals = null;
-  if (openhandsEventsPath) {
-    const absoluteOpenhandsPath = path.isAbsolute(openhandsEventsPath)
-      ? openhandsEventsPath
-      : path.join(projectPath, openhandsEventsPath);
-    const rawOpenhandsEvents = await readOpenHandsEventsFile(absoluteOpenhandsPath, fileSystem);
-    openhandsSignals = mapOpenHandsEventsToTaskSignals(rawOpenhandsEvents, {
-      jobId: job.job_id
-    });
-    events = openhandsSignals.event;
-    sourceStream = 'openhands';
-  }
 
   const payload = await buildCommandPayload('studio-events', job, {
     events,
@@ -2941,47 +2660,11 @@ async function runStudioEventsCommand(options = {}, dependencies = {}) {
     fileSystem
   });
   payload.limit = limit;
-  payload.source_stream = sourceStream;
-  if (sourceStream === 'openhands') {
-    payload.openhands_events_file = path.relative(projectPath, path.isAbsolute(openhandsEventsPath)
-      ? openhandsEventsPath
-      : path.join(projectPath, openhandsEventsPath)).replace(/\\/g, '/');
-    payload.task = {
-      ...payload.task,
-      summary: [
-        `OpenHands events: ${events.length} | commands: ${openhandsSignals.commands.length} | errors: ${openhandsSignals.errors.length}`,
-        `File changes: ${openhandsSignals.file_changes.length} | source: ${payload.openhands_events_file}`,
-        `Next: ${payload.task.next_action}`
-      ],
-      handoff: {
-        ...(payload.task.handoff || {}),
-        source_stream: 'openhands',
-        openhands_event_count: events.length,
-        openhands_command_count: openhandsSignals.commands.length,
-        openhands_error_count: openhandsSignals.errors.length
-      },
-      commands: openhandsSignals.commands,
-      file_changes: openhandsSignals.file_changes,
-      errors: openhandsSignals.errors,
-      evidence: normalizeTaskEvidence([
-        ...(Array.isArray(payload.task.evidence) ? payload.task.evidence : []),
-        ...openhandsSignals.evidence,
-        {
-          type: 'openhands-event-file',
-          ref: payload.openhands_events_file,
-          detail: 'mapped'
-        }
-      ])
-    };
-    payload.eventId = events.length > 0
-      ? events[events.length - 1].event_id
-      : null;
-  }
+  payload.source_stream = 'studio';
   payload.events = events;
   const normalizedPayload = attachTaskFeedbackModel(payload);
   printStudioEventsPayload(normalizedPayload, options);
   return normalizedPayload;
-  return payload;
 }
 
 function printStudioIntakePayload(payload, options = {}) {
@@ -3267,7 +2950,6 @@ function registerStudioCommands(program) {
     .description('Show studio job event stream')
     .option('--job <job-id>', 'Studio job id (defaults to latest)')
     .option('--limit <number>', 'Maximum number of recent events to return', '50')
-    .option('--openhands-events <path>', 'Optional OpenHands raw events file (.json/.jsonl) mapped to task stream')
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => runStudioCommand(runStudioEventsCommand, options, 'events'));
 

package/lib/project/candidate-inspection-service.js

@@ -0,0 +1,216 @@
+const path = require('path');
+const fs = require('fs-extra');
+const WorkspaceStateManager = require('../workspace/multi/workspace-state-manager');
+const {
+  buildLocalProjectId,
+  buildWorkspaceProjectId
+} = require('./portfolio-projection-service');
+
+const PROJECT_CANDIDATE_REASON_CODES = {
+  ROOT_ACCESSIBLE: 'project.root.accessible',
+  ROOT_INACCESSIBLE: 'project.root.inaccessible',
+  ROOT_INVALID_TYPE: 'project.root.invalid_type',
+  WORKSPACE_REGISTERED: 'project.workspace.registered',
+  SCE_PRESENT: 'project.sce.present',
+  ROOT_NOT_INITIALIZED: 'project.root.not_initialized',
+  INVALID_PROJECT_METADATA: 'project.metadata.invalid',
+  UNREGISTERED_PROJECT: 'project.sce.unregistered'
+};
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizePath(value) {
+  return normalizeString(value).replace(/\\/g, '/');
+}
+
+function buildProjectName(rootDir) {
+  return path.basename(rootDir) || 'project';
+}
+
+async function resolveExactWorkspaceByRoot(rootDir, stateManager) {
+  const workspaces = await stateManager.listWorkspaces();
+  const normalizedRoot = normalizePath(rootDir);
+  return workspaces.find((workspace) => normalizePath(workspace && workspace.path) === normalizedRoot) || null;
+}
+
+async function inspectSceMetadata(rootDir, fileSystem = fs) {
+  const sceRoot = path.join(rootDir, '.sce');
+  if (!await fileSystem.pathExists(sceRoot)) {
+    return {
+      scePresent: false,
+      metadataValid: true,
+      metadataReasonCodes: []
+    };
+  }
+
+  try {
+    const sceStats = await fileSystem.stat(sceRoot);
+    if (!sceStats.isDirectory()) {
+      return {
+        scePresent: false,
+        metadataValid: false,
+        metadataReasonCodes: [PROJECT_CANDIDATE_REASON_CODES.ROOT_INVALID_TYPE]
+      };
+    }
+  } catch (_error) {
+    return {
+      scePresent: false,
+      metadataValid: false,
+      metadataReasonCodes: [PROJECT_CANDIDATE_REASON_CODES.ROOT_INACCESSIBLE]
+    };
+  }
+
+  const versionPath = path.join(sceRoot, 'version.json');
+  if (!await fileSystem.pathExists(versionPath)) {
+    return {
+      scePresent: true,
+      metadataValid: true,
+      metadataReasonCodes: [PROJECT_CANDIDATE_REASON_CODES.SCE_PRESENT]
+    };
+  }
+
+  try {
+    await fileSystem.readJson(versionPath);
+    return {
+      scePresent: true,
+      metadataValid: true,
+      metadataReasonCodes: [PROJECT_CANDIDATE_REASON_CODES.SCE_PRESENT]
+    };
+  } catch (_error) {
+    return {
+      scePresent: true,
+      metadataValid: false,
+      metadataReasonCodes: [
+        PROJECT_CANDIDATE_REASON_CODES.SCE_PRESENT,
+        PROJECT_CANDIDATE_REASON_CODES.INVALID_PROJECT_METADATA
+      ]
+    };
+  }
+}
+
+function dedupeReasonCodes(reasonCodes = []) {
+  return Array.from(new Set(reasonCodes.filter(Boolean)));
+}
+
+async function inspectProjectCandidate(options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const stateManager = dependencies.stateManager || new WorkspaceStateManager(dependencies.workspaceStatePath);
+  const requestedRoot = normalizeString(options.root || options.rootDir);
+  if (!requestedRoot) {
+    throw new Error('--root is required');
+  }
+
+  const absoluteRoot = path.resolve(requestedRoot);
+  const rootDir = normalizePath(absoluteRoot);
+  const inspectedAt = new Date().toISOString();
+  const projectName = buildProjectName(rootDir);
+
+  if (!await fileSystem.pathExists(absoluteRoot)) {
+    return {
+      inspectedAt,
+      rootDir,
+      kind: 'invalid',
+      projectName,
+      readiness: 'blocked',
+      availability: 'inaccessible',
+      localCandidate: false,
+      reasonCodes: [PROJECT_CANDIDATE_REASON_CODES.ROOT_INACCESSIBLE]
+    };
+  }
+
+  let rootStats = null;
+  try {
+    rootStats = await fileSystem.stat(absoluteRoot);
+  } catch (_error) {
+    return {
+      inspectedAt,
+      rootDir,
+      kind: 'invalid',
+      projectName,
+      readiness: 'blocked',
+      availability: 'inaccessible',
+      localCandidate: false,
+      reasonCodes: [PROJECT_CANDIDATE_REASON_CODES.ROOT_INACCESSIBLE]
+    };
+  }
+
+  if (!rootStats.isDirectory()) {
+    return {
+      inspectedAt,
+      rootDir,
+      kind: 'invalid',
+      projectName,
+      readiness: 'blocked',
+      availability: 'degraded',
+      localCandidate: false,
+      reasonCodes: [PROJECT_CANDIDATE_REASON_CODES.ROOT_INVALID_TYPE]
+    };
+  }
+
+  const workspace = await resolveExactWorkspaceByRoot(absoluteRoot, stateManager);
+  const sceInspection = await inspectSceMetadata(absoluteRoot, fileSystem);
+  const metadataBlocked = sceInspection.scePresent && !sceInspection.metadataValid;
+
+  if (workspace) {
+    const workspaceBlocked = !sceInspection.scePresent || metadataBlocked;
+    return {
+      inspectedAt,
+      rootDir,
+      kind: 'workspace-backed',
+      projectId: buildWorkspaceProjectId(workspace.name),
+      workspaceId: workspace.name,
+      projectName,
+      readiness: workspaceBlocked ? 'blocked' : 'ready',
+      availability: workspaceBlocked ? 'degraded' : 'accessible',
+      localCandidate: false,
+      reasonCodes: dedupeReasonCodes([
+        PROJECT_CANDIDATE_REASON_CODES.WORKSPACE_REGISTERED,
+        PROJECT_CANDIDATE_REASON_CODES.ROOT_ACCESSIBLE,
+        ...(!sceInspection.scePresent ? [PROJECT_CANDIDATE_REASON_CODES.ROOT_NOT_INITIALIZED] : []),
+        ...sceInspection.metadataReasonCodes
+      ])
+    };
+  }
+
+  if (sceInspection.scePresent) {
+    return {
+      inspectedAt,
+      rootDir,
+      kind: 'local-sce-candidate',
+      projectId: buildLocalProjectId(rootDir),
+      projectName,
+      readiness: metadataBlocked ? 'blocked' : 'partial',
+      availability: metadataBlocked ? 'degraded' : 'degraded',
+      localCandidate: true,
+      reasonCodes: dedupeReasonCodes([
+        PROJECT_CANDIDATE_REASON_CODES.ROOT_ACCESSIBLE,
+        PROJECT_CANDIDATE_REASON_CODES.UNREGISTERED_PROJECT,
+        ...sceInspection.metadataReasonCodes
+      ])
+    };
+  }
+
+  return {
+    inspectedAt,
+    rootDir,
+    kind: 'directory-candidate',
+    projectName,
+    readiness: 'pending',
+    availability: 'accessible',
+    localCandidate: true,
+    reasonCodes: [
+      PROJECT_CANDIDATE_REASON_CODES.ROOT_ACCESSIBLE,
+      PROJECT_CANDIDATE_REASON_CODES.ROOT_NOT_INITIALIZED
+    ]
+  };
+}
+
+module.exports = {
+  PROJECT_CANDIDATE_REASON_CODES,
+  inspectProjectCandidate
+};