open-research-protocol 0.4.14 → 0.4.15

package/packages/orp-workspace-launcher/src/slot.js

@@ -0,0 +1,188 @@
+import process from "node:process";
+
+import { buildWorkspaceInventory, applyWorkspaceSlotsToInventory } from "./list.js";
+import { buildWorkspaceSlotAssignment, fetchHostedWorkspacesPayload, fetchIdeasPayload, resolveWorkspaceSelectorFromCollections } from "./orp.js";
+import { clearWorkspaceSlot, listTrackedWorkspaces, loadWorkspaceSlots, normalizeWorkspaceSlotName, setWorkspaceSlot } from "./registry.js";
+
+function normalizeOptionalString(value) {
+  if (value == null) {
+    return null;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function printWorkspaceSlotHelp() {
+  console.log(`ORP workspace slot
+
+Usage:
+  orp workspace slot list [--json]
+  orp workspace slot set <main|offhand> <name-or-id> [--json]
+  orp workspace slot clear <main|offhand> [--json]
+
+Examples:
+  orp workspace slot list
+  orp workspace slot set main main-cody-1
+  orp workspace slot set offhand research-lab
+  orp workspace slot clear offhand
+`);
+}
+
+function parseWorkspaceSlotArgs(argv = []) {
+  const options = {
+    json: false,
+  };
+
+  const positionals = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    positionals.push(arg);
+  }
+
+  options.subcommand = positionals[0] || null;
+  options.slotName = positionals[1] || null;
+  options.selector = positionals[2] || null;
+  if (positionals.length > 3) {
+    throw new Error(`unexpected argument: ${positionals[3]}`);
+  }
+  return options;
+}
+
+function summarizeSlotInventory(payload) {
+  const lines = ["Workspace slots"];
+  for (const slotName of ["main", "offhand"]) {
+    const slot = payload?.slots?.[slotName] || null;
+    if (!slot) {
+      lines.push(`${slotName}: unset`);
+      continue;
+    }
+    const label = normalizeOptionalString(slot.title) || normalizeOptionalString(slot.workspaceId) || normalizeOptionalString(slot.selector) || "unknown";
+    const extra =
+      normalizeOptionalString(slot.kind) === "workspace-file"
+        ? slot.manifestPath
+        : normalizeOptionalString(slot.ideaId) || normalizeOptionalString(slot.hostedWorkspaceId) || normalizeOptionalString(slot.workspaceId);
+    lines.push(`${slotName}: ${label}${extra ? ` [${extra}]` : ""}`);
+  }
+  return lines.join("\n");
+}
+
+async function buildSlotInventory(options = {}) {
+  const [localResult, slotsResult] = await Promise.all([listTrackedWorkspaces(options), loadWorkspaceSlots(options)]);
+  let hostedResult = { source: null, workspaces: [] };
+  try {
+    hostedResult = await fetchHostedWorkspacesPayload(options);
+  } catch {
+    hostedResult = { source: null, workspaces: [] };
+  }
+  return applyWorkspaceSlotsToInventory(
+    buildWorkspaceInventory({
+      localResult,
+      hostedResult,
+      hostedError: null,
+    }),
+    slotsResult.slots,
+  );
+}
+
+async function resolveWorkspaceSelection(selector, options = {}) {
+  const [ideasPayload, hostedResult, localRegistry] = await Promise.all([
+    fetchIdeasPayload(options).catch(() => ({ ideas: [] })),
+    fetchHostedWorkspacesPayload(options).catch(() => ({ workspaces: [] })),
+    listTrackedWorkspaces(options).catch(() => ({ workspaces: [] })),
+  ]);
+  return resolveWorkspaceSelectorFromCollections(selector, {
+    ideas: ideasPayload.ideas,
+    hostedWorkspaces: hostedResult.workspaces,
+    localWorkspaces: localRegistry.workspaces,
+  });
+}
+
+export async function runWorkspaceSlot(argv = process.argv.slice(2)) {
+  const options = parseWorkspaceSlotArgs(argv);
+  if (options.help || !options.subcommand) {
+    printWorkspaceSlotHelp();
+    return 0;
+  }
+
+  if (options.subcommand === "list") {
+    const inventory = await buildSlotInventory(options);
+    const payload = {
+      ok: true,
+      slots: inventory.slots || {},
+      workspaces: inventory.workspaces.filter((workspace) => Array.isArray(workspace.slots) && workspace.slots.length > 0),
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return 0;
+    }
+    process.stdout.write(`${summarizeSlotInventory(payload)}\n`);
+    return 0;
+  }
+
+  const slotName = normalizeWorkspaceSlotName(options.slotName);
+  if (!slotName) {
+    throw new Error("Provide a supported slot name: main or offhand.");
+  }
+
+  if (options.subcommand === "clear") {
+    const result = await clearWorkspaceSlot(slotName, options);
+    const payload = {
+      ok: true,
+      slotName,
+      cleared: result.cleared,
+      slotsPath: result.slotsPath,
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return 0;
+    }
+    process.stdout.write(
+      `${result.cleared ? "Cleared" : "Left unchanged"} workspace slot '${slotName}'.\n`,
+    );
+    return 0;
+  }
+
+  if (options.subcommand === "set") {
+    const selector = normalizeOptionalString(options.selector);
+    if (!selector) {
+      throw new Error(`Provide a workspace name or id to assign to '${slotName}'.`);
+    }
+    if (normalizeWorkspaceSlotName(selector)) {
+      throw new Error(`Use a real workspace title or id when assigning '${slotName}', not another slot name.`);
+    }
+
+    const candidate = await resolveWorkspaceSelection(selector, options);
+    if (!candidate) {
+      throw new Error(`Workspace not found: ${selector}`);
+    }
+    const assignment = buildWorkspaceSlotAssignment(candidate);
+    const result = await setWorkspaceSlot(slotName, assignment, options);
+    const payload = {
+      ok: true,
+      slotName,
+      slot: result.slot,
+      slotsPath: result.slotsPath,
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return 0;
+    }
+    const label =
+      normalizeOptionalString(result.slot.title) ||
+      normalizeOptionalString(result.slot.workspaceId) ||
+      normalizeOptionalString(result.slot.selector) ||
+      "workspace";
+    process.stdout.write(`Assigned workspace slot '${slotName}' to '${label}'.\n`);
+    return 0;
+  }
+
+  throw new Error(`unknown workspace slot subcommand: ${options.subcommand}`);
+}

package/packages/orp-workspace-launcher/src/sync.js

@@ -0,0 +1,363 @@
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+
+import {
+  deriveBaseTitle,
+  deriveWorkspaceId,
+  getResumeCommand,
+  parseWorkspaceSource,
+  resolveResumeMetadata,
+  WORKSPACE_SCHEMA_VERSION,
+} from "./core-plan.js";
+import { fetchIdeaPayload, loadWorkspaceSource, updateIdeaPayload } from "./orp.js";
+import { cacheManagedWorkspaceManifest } from "./registry.js";
+
+const STRUCTURED_WORKSPACE_BLOCK_PATTERN = /```orp-workspace\s*[\s\S]*?```/i;
+const WORKSPACE_TITLE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+function printSyncHelp() {
+  console.log(`ORP workspace sync
+
+Usage:
+  orp workspace sync <name-or-id> [--workspace-file <path> | --notes-file <path>] [--title <slug>] [--dry-run] [--json]
+
+Options:
+  --workspace-file <path> Read a structured workspace manifest JSON file
+  --notes-file <path>     Read a local notes file and normalize launchable paths into a manifest
+  --title <slug>          Required when the source workspace does not already have a saved title
+  --dry-run               Print the sync preview without updating the hosted idea
+  --json                  Print the sync preview as JSON
+  --base-url <url>        Override the ORP hosted base URL
+  --orp-command <cmd>     Override the ORP CLI executable used for hosted fetches/updates
+  -h, --help              Show this help text
+
+Examples:
+  orp workspace sync main
+  orp workspace sync main --workspace-file ./workspace.json --title main-cody-1
+  orp workspace sync main --notes-file ./workspace-notes.txt --title main-cody-1 --dry-run
+`);
+}
+
+function normalizeOptionalString(value) {
+  if (value == null) {
+    return null;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function parseWorkspaceSyncArgs(argv = []) {
+  const options = {
+    dryRun: false,
+    json: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const next = argv[index + 1];
+      if (next == null || next.startsWith("--")) {
+        throw new Error(`missing value for ${arg}`);
+      }
+      if (arg === "--workspace-file") {
+        options.workspaceFile = next;
+      } else if (arg === "--notes-file") {
+        options.notesFile = next;
+      } else if (arg === "--title") {
+        options.title = next;
+      } else if (arg === "--base-url") {
+        options.baseUrl = next;
+      } else if (arg === "--orp-command") {
+        options.orpCommand = next;
+      } else {
+        throw new Error(`unknown option: ${arg}`);
+      }
+      index += 1;
+      continue;
+    }
+
+    if (options.ideaId) {
+      throw new Error(`unexpected argument: ${arg}`);
+    }
+    options.ideaId = arg;
+  }
+
+  return options;
+}
+
+function getLinkedIdeaIdFromWorkspaceRecord(workspace) {
+  if (!workspace || typeof workspace !== "object" || Array.isArray(workspace)) {
+    return null;
+  }
+  const linkedIdea =
+    workspace.linked_idea && typeof workspace.linked_idea === "object" && !Array.isArray(workspace.linked_idea)
+      ? workspace.linked_idea
+      : workspace.linkedIdea && typeof workspace.linkedIdea === "object" && !Array.isArray(workspace.linkedIdea)
+        ? workspace.linkedIdea
+        : null;
+  return normalizeOptionalString(linkedIdea?.idea_id ?? linkedIdea?.ideaId);
+}
+
+export function resolveWorkspaceSyncTargetIdeaId(source) {
+  if (!source || typeof source !== "object" || Array.isArray(source)) {
+    return null;
+  }
+  if (source.sourceType === "hosted-idea") {
+    return normalizeOptionalString(source.idea?.id);
+  }
+  if (source.sourceType === "hosted-workspace") {
+    return getLinkedIdeaIdFromWorkspaceRecord(source.hostedWorkspace);
+  }
+  return null;
+}
+
+async function resolveWorkspaceSyncTargetSource(source, options) {
+  if (!options.workspaceFile && !options.notesFile && (source.sourceType === "hosted-idea" || source.sourceType === "hosted-workspace")) {
+    return source;
+  }
+  return loadWorkspaceSource({
+    ideaId: options.ideaId,
+    baseUrl: options.baseUrl,
+    orpCommand: options.orpCommand,
+  });
+}
+
+export function validateWorkspaceTitle(value, label = "--title") {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    throw new Error(`${label} is required and must use lowercase letters, numbers, and dashes only.`);
+  }
+  if (!WORKSPACE_TITLE_PATTERN.test(normalized)) {
+    throw new Error(`${label} must use lowercase letters, numbers, and single dashes only, like main-cody-1.`);
+  }
+  return normalized;
+}
+
+async function promptForWorkspaceTitle() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Workspace title is required. Provide --title <slug> with lowercase letters, numbers, and dashes only.");
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = await rl.question("Workspace title (lowercase-dash format, example: main-cody-1): ");
+    return validateWorkspaceTitle(answer, "workspace title");
+  } finally {
+    rl.close();
+  }
+}
+
+function normalizeNotesBody(value) {
+  return String(value || "")
+    .replace(/\r\n/g, "\n")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function combineNoteSections(sections) {
+  return sections
+    .map((section) => normalizeNotesBody(section))
+    .filter((section) => section.length > 0)
+    .join("\n\n");
+}
+
+export function extractWorkspaceNarrativeNotes(notes, options = {}) {
+  const withoutStructuredBlock = String(notes || "").replace(STRUCTURED_WORKSPACE_BLOCK_PATTERN, "");
+  const lines = withoutStructuredBlock.split(/\r?\n/);
+  const filteredLines = options.stripLegacyWorkspaceLines
+    ? lines.filter((line) => !line.trim().startsWith("/"))
+    : lines;
+  return normalizeNotesBody(filteredLines.join("\n"));
+}
+
+function serializeWorkspaceManifest(manifest) {
+  const tabs = manifest.tabs.map((entry) =>
+    Object.fromEntries(
+      Object.entries({
+        title: normalizeOptionalString(entry.title) ?? undefined,
+        path: String(entry.path).trim(),
+        resumeCommand: normalizeOptionalString(entry.resumeCommand) ?? undefined,
+        resumeTool: normalizeOptionalString(entry.resumeTool) ?? undefined,
+        resumeSessionId: normalizeOptionalString(entry.resumeSessionId ?? entry.sessionId) ?? undefined,
+        codexSessionId:
+          normalizeOptionalString(entry.resumeTool) === "codex"
+            ? normalizeOptionalString(entry.codexSessionId ?? entry.resumeSessionId ?? entry.sessionId) ?? undefined
+            : undefined,
+        claudeSessionId:
+          normalizeOptionalString(entry.resumeTool) === "claude"
+            ? normalizeOptionalString(entry.claudeSessionId ?? entry.resumeSessionId ?? entry.sessionId) ?? undefined
+            : undefined,
+      }).filter(([, value]) => value !== undefined),
+    ),
+  );
+
+  const normalized = Object.fromEntries(
+    Object.entries({
+      version: WORKSPACE_SCHEMA_VERSION,
+      workspaceId: normalizeOptionalString(manifest.workspaceId) ?? undefined,
+      title: normalizeOptionalString(manifest.title) ?? undefined,
+      tabs,
+    }).filter(([, value]) => value !== undefined),
+  );
+
+  return JSON.stringify(normalized, null, 2);
+}
+
+function composeWorkspaceNotes({ narrativeNotes, manifest }) {
+  return combineNoteSections([
+    narrativeNotes,
+    `\`\`\`orp-workspace\n${serializeWorkspaceManifest(manifest)}\n\`\`\``,
+  ]);
+}
+
+export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspaceTitle = null }) {
+  const manifest = parsed.manifest
+    ? {
+        version: parsed.manifest.version || WORKSPACE_SCHEMA_VERSION,
+        workspaceId: parsed.manifest.workspaceId || workspaceTitle || deriveWorkspaceId(source, parsed),
+        title: workspaceTitle || parsed.manifest.title || null,
+        tabs: parsed.manifest.tabs.map((entry) => ({
+          title: entry.title || deriveBaseTitle(entry),
+          path: entry.path,
+          resumeCommand: entry.resumeCommand || null,
+          resumeTool: entry.resumeTool || null,
+          resumeSessionId: entry.sessionId || null,
+          codexSessionId: entry.resumeTool === "codex" ? entry.sessionId || null : null,
+          claudeSessionId: entry.resumeTool === "claude" ? entry.sessionId || null : null,
+        })),
+      }
+    : {
+        version: WORKSPACE_SCHEMA_VERSION,
+        workspaceId: workspaceTitle || deriveWorkspaceId(source, parsed),
+        title: workspaceTitle || null,
+        tabs: parsed.entries.map((entry) => ({
+          title: deriveBaseTitle(entry),
+          path: entry.path,
+          resumeCommand: getResumeCommand(entry),
+          resumeTool: resolveResumeMetadata(entry).resumeTool,
+          resumeSessionId: resolveResumeMetadata(entry).resumeSessionId,
+          codexSessionId:
+            resolveResumeMetadata(entry).resumeTool === "codex" ? resolveResumeMetadata(entry).resumeSessionId : null,
+          claudeSessionId:
+            resolveResumeMetadata(entry).resumeTool === "claude" ? resolveResumeMetadata(entry).resumeSessionId : null,
+        })),
+      };
+
+  const narrativeSourceNotes =
+    source.sourceType === "workspace-file" ? targetIdea.notes || "" : source.notes || targetIdea.notes || "";
+  const narrativeNotes = extractWorkspaceNarrativeNotes(narrativeSourceNotes, {
+    stripLegacyWorkspaceLines: source.sourceType === "workspace-file",
+  });
+  const nextNotes = composeWorkspaceNotes({
+    narrativeNotes,
+    manifest,
+  });
+
+  return {
+    targetIdeaId: targetIdea.id,
+    targetIdeaTitle: targetIdea.title,
+    sourceType: source.sourceType,
+    sourceLabel: source.sourceLabel,
+    parseMode: parsed.parseMode,
+    workspaceId: manifest.workspaceId,
+    manifest,
+    nextNotes,
+    nextNotesLength: nextNotes.length,
+    tabs: manifest.tabs,
+    skipped: parsed.skipped,
+  };
+}
+
+function summarizeSyncPreview(preview) {
+  const lines = [
+    `Workspace sync preview`,
+    `  target: ${preview.targetIdeaTitle} (${preview.targetIdeaId})`,
+    `  source: ${preview.sourceType} (${preview.sourceLabel})`,
+    `  parse mode: ${preview.parseMode}`,
+    `  workspace id: ${preview.workspaceId}`,
+    `  tabs: ${preview.tabs.length}`,
+    `  stored notes: ${preview.nextNotesLength} chars`,
+  ];
+
+  if (preview.skipped.length > 0) {
+    lines.push(`  skipped non-path lines: ${preview.skipped.length}`);
+  }
+  return lines.join("\n");
+}
+
+export async function runWorkspaceSync(argv = process.argv.slice(2)) {
+  const options = parseWorkspaceSyncArgs(argv);
+  if (options.help) {
+    printSyncHelp();
+    return 0;
+  }
+  if (!options.ideaId) {
+    throw new Error("Provide the hosted workspace selector that should receive the synced workspace.");
+  }
+
+  const source = await loadWorkspaceSource(options);
+  const parsed = parseWorkspaceSource(source);
+  if (parsed.entries.length === 0) {
+    throw new Error("No launchable workspace lines were found in the provided source.");
+  }
+  const resolvedWorkspaceTitle = options.title
+    ? validateWorkspaceTitle(options.title)
+    : normalizeOptionalString(parsed.manifest?.title) || (await promptForWorkspaceTitle());
+  const targetSource = await resolveWorkspaceSyncTargetSource(source, options);
+  const targetIdeaId = resolveWorkspaceSyncTargetIdeaId(targetSource);
+  if (!targetIdeaId) {
+    throw new Error(
+      `Workspace sync target '${options.ideaId}' does not resolve to a hosted idea-backed workspace. Use a synced hosted selector like main, an idea id, or a workspace linked to a hosted idea.`,
+    );
+  }
+
+  const targetPayload =
+    targetSource.sourceType === "hosted-idea" && targetSource.idea?.id === targetIdeaId
+      ? targetSource.payload
+      : await fetchIdeaPayload(targetIdeaId, options);
+
+  if (!targetPayload?.idea) {
+    throw new Error("Unable to resolve the hosted ORP idea for workspace sync.");
+  }
+
+  const preview = buildWorkspaceSyncPreview({
+    source,
+    parsed,
+    targetIdea: targetPayload.idea,
+    workspaceTitle: resolvedWorkspaceTitle,
+  });
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(preview, null, 2)}\n`);
+    return 0;
+  }
+
+  if (options.dryRun) {
+    process.stdout.write(`${summarizeSyncPreview(preview)}\n`);
+    return 0;
+  }
+
+  const updated = await updateIdeaPayload(targetIdeaId, { notes: preview.nextNotes }, options);
+  const managedCache = await cacheManagedWorkspaceManifest(preview.manifest);
+  process.stdout.write(
+    `Synced workspace '${preview.workspaceId}' to idea '${updated.title || preview.targetIdeaTitle}'.\n`,
+  );
+  process.stdout.write(`Tabs: ${preview.tabs.length}. Stored notes: ${preview.nextNotesLength} chars.\n`);
+  process.stdout.write(`Updated local workspace cache at ${managedCache.manifestPath}.\n`);
+  return 0;
+}