vibe64 0.1.21

package/packages/vibe64-adapters/src/server/systemPrompts/resolve_pull_request.txt

@@ -0,0 +1,28 @@
+Draft pull request details for Vibe64.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+Action context:
+{{session.stepMachine.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Goal:
+- Inspect the current repository state and draft the pull request title and body.
+- Do not create the pull request.
+- Do not write Vibe64 artifacts directly.
+- Submit the result only by following the Vibe64 step completion contract appended to this prompt.
+
+Body guidance:
+- Summarize the user-visible change.
+- List important files or areas changed.
+- List verification already run, or clearly say when verification is still pending.
+- Mention blockers or risks only when they matter to the reviewer.
+
+After the helper reports success, stop.

package/packages/vibe64-adapters/src/server/systemPrompts/run_deep_ui_check.txt

@@ -0,0 +1,22 @@
+Run deep UI check
+
+Vibe64 standard deep UI check instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Inspect the user-facing application behavior carefully. Focus on real UI defects, broken flows, layout issues, state mistakes, and mismatches with the requested work. Fix clear defects directly when the project supports it. Report what you changed, which checks ran, and why no edit was needed if the UI is already sound.

package/packages/vibe64-adapters/src/server/systemPrompts/run_deslop.txt

@@ -0,0 +1,25 @@
+Run deslop
+
+Vibe64 standard review/deslop instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Code index policy:
+If session metadata includes `code_index_path`, read that generated code index before reviewing helper-like code, duplicated methods, shared service functions, provider wiring, or reusable project structures. Treat duplicates against that index as concrete deslop findings.
+
+Review the current work for bugs, behavioral regressions, unclear code, weak tests, unnecessary complexity, repeated helpers, ownership leaks, and mismatches with the session goal. Lead with concrete findings. Mark findings as [high], [medium] or [low]. Run one subagent per discovered problem, getting it to make targeted changes to fix it. Repeat the whole process (discovery, subagents run), and stop when only [low] issues are reported. At the end, report what you changed, which checks ran, and what remains unresolved.

package/packages/vibe64-adapters/src/server/systemPrompts/update_project_knowledge.txt

@@ -0,0 +1,22 @@
+Update project knowledge
+
+Vibe64 standard project-knowledge instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Update the project knowledge artifact referenced by the adapter prompt context. Preserve useful existing information, remove stale claims, and keep the result concise enough to maintain. If the adapter does not provide a project knowledge location, report that clearly instead of inventing one.

package/packages/vibe64-adapters/src/server/systemPrompts/write_report.txt

@@ -0,0 +1,33 @@
+Write report
+
+Vibe64 standard session-report instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+- artifacts root: {{session.artifactsRoot}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Write a concise Markdown report and submit it through the current-step input helper. Do not write the report artifact directly.
+
+This step runs after human review. The report is for the user and for later issue or pull request context. Include:
+- The requested outcome.
+- What changed.
+- Why the implementation was done that way.
+- Important files or areas touched.
+- Checks and reviews run.
+- Remaining risks, follow-ups, or unverified items.
+
+Use the current Codex conversation, session metadata, issue, plan, worktree changes, and verification output as context. Keep the report factual and useful. Do not modify project files while writing the report.

package/packages/vibe64-adapters/src/server/workflowAdapter.js

@@ -0,0 +1,463 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+import {
+  TargetAdapter,
+  adapterActionResult,
+  adapterCommand,
+  adapterDetection,
+  adapterLaunchTarget,
+  adapterTerminalToolchainSpec
+} from "./adapter.js";
+import {
+  vibe64Error,
+  isMissingPathError,
+  normalizeText,
+  pathExists
+} from "@local/vibe64-core/server/core";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  PromptRenderer
+} from "./promptRenderer.js";
+import {
+  createVibe64WorkflowCommandTerminalSpec
+} from "./workflowCommandTerminal.js";
+import {
+  runVibe64WorkflowSessionAction
+} from "./workflowSessionActions.js";
+
+const VIBE64_WORKFLOW_COMMANDS = deepFreeze([
+  {
+    id: "commit_changes",
+    label: "Commit and push changes"
+  },
+  {
+    id: "create_issue_on_gh",
+    label: "Create issue on GH"
+  },
+  {
+    id: "create_pr_on_gh",
+    label: "Create PR on GH"
+  },
+  {
+    id: "create_worktree",
+    label: "Create worktree"
+  },
+  {
+    id: "finish_session",
+    label: "Archive session"
+  },
+  {
+    id: "install_dependencies",
+    label: "Install dependencies"
+  },
+  {
+    id: "merge_pr",
+    label: "Merge PR"
+  },
+  {
+    id: "run_automated_checks",
+    label: "Run automated checks"
+  },
+  {
+    id: "sync_main_checkout",
+    label: "Sync main checkout"
+  },
+  {
+    id: "update_code_index",
+    label: "Update code index"
+  }
+]);
+
+const VIBE64_WORKFLOW_SESSION_ACTION_CAPABILITIES = deepFreeze([
+  "use_existing_issue",
+  "use_existing_pr"
+]);
+
+function normalizeWorkflowCommands(commands = []) {
+  return commands
+    .map(adapterCommand)
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function normalizeLaunchTargets(targets = []) {
+  return targets
+    .map(adapterLaunchTarget)
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function vibe64WorkflowCapabilities({
+  commands = [],
+  extraCapabilities = []
+} = {}) {
+  return {
+    ...Object.fromEntries(normalizeWorkflowCommands(commands).map((command) => [command.id, true])),
+    ...Object.fromEntries(VIBE64_WORKFLOW_SESSION_ACTION_CAPABILITIES.map((capability) => [capability, true])),
+    ...Object.fromEntries(extraCapabilities.map(normalizeText).filter(Boolean).map((capability) => [capability, true]))
+  };
+}
+
+class Vibe64WorkflowTargetAdapter extends TargetAdapter {
+  constructor({
+    commandTerminalSpecFactory = null,
+    commands = [],
+    id = "generic",
+    label = "Generic target",
+    prepareWorktreeScriptPath = ""
+  } = {}) {
+    super({
+      id,
+      label
+    });
+    this.commandTerminalSpecFactory = typeof commandTerminalSpecFactory === "function"
+      ? commandTerminalSpecFactory
+      : null;
+    this.commands = normalizeWorkflowCommands(commands);
+    this.prepareWorktreeScriptPath = prepareWorktreeScriptPath;
+  }
+
+  workflowCapabilities(extra = {}) {
+    return vibe64WorkflowCapabilities({
+      commands: this.commands,
+      ...extra
+    });
+  }
+
+  async listCommands({ facts = {} } = {}) {
+    return (facts.commands || this.commands).map(adapterCommand);
+  }
+
+  async getWorkflowCommandHooks() {
+    return {};
+  }
+
+  async getPrepareWorktreeScriptPath(context = {}) {
+    return normalizeText(await resolveValue(this.prepareWorktreeScriptPath, context));
+  }
+
+  async createCommandTerminalSpec(commandId, context = {}) {
+    if (this.commandTerminalSpecFactory) {
+      return this.commandTerminalSpecFactory({
+        commandId,
+        context,
+        targetRoot: context.session?.targetRoot || context.targetRoot || ""
+      });
+    }
+    return createVibe64WorkflowCommandTerminalSpec({
+      commandId,
+      context,
+      hooks: await this.getWorkflowCommandHooks(context),
+      prepareWorktreeScriptPath: await this.getPrepareWorktreeScriptPath(context),
+      targetRoot: context.session?.targetRoot || context.targetRoot || ""
+    });
+  }
+
+  async runSessionAction({
+    action = {},
+    input = {},
+    session = {}
+  } = {}) {
+    return runVibe64WorkflowSessionAction(action.id, {
+      input,
+      session,
+      targetRoot: session.targetRoot || process.cwd()
+    });
+  }
+
+  async finishSession() {
+    return adapterActionResult({
+      message: "Finished Vibe64 session.",
+      metadata: {
+        session_finished: "yes"
+      },
+      status: "completed"
+    });
+  }
+}
+
+function resolveValue(value, context = {}) {
+  return typeof value === "function" ? value(context) : value;
+}
+
+function createPromptRenderer({
+  promptPackRoot = "",
+  promptRenderer = null
+} = {}) {
+  if (promptRenderer) {
+    return promptRenderer;
+  }
+  return promptPackRoot
+    ? new PromptRenderer({
+        promptPackRoot
+      })
+    : null;
+}
+
+async function readOptionalProjectJson(filePath, {
+  defaultValue = null,
+  invalidJsonCode = "vibe64_invalid_project_json",
+  invalidJsonMessage = (invalidPath) => `Invalid JSON in project file: ${invalidPath}`
+} = {}) {
+  let text = "";
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    return defaultValue;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw vibe64Error(invalidJsonMessage(filePath), invalidJsonCode);
+  }
+}
+
+async function inspectProjectMarkers(targetRoot, markers = []) {
+  return Promise.all(markers.map(async (marker) => {
+    return {
+      ...marker,
+      exists: await pathExists(path.join(targetRoot, marker.relativePath))
+    };
+  }));
+}
+
+async function inspectDescribedProject(targetRoot, {
+  extra = () => ({}),
+  markers = [],
+  packageJson = {}
+} = {}) {
+  const resolvedTargetRoot = path.resolve(targetRoot || process.cwd());
+  const packageJsonOptions = {
+    defaultValue: null,
+    invalidJsonCode: "vibe64_invalid_project_json",
+    invalidJsonMessage: (filePath) => `Invalid JSON in project file: ${filePath}`,
+    key: "packageJson",
+    relativePath: "package.json",
+    ...packageJson
+  };
+  const markerResults = await inspectProjectMarkers(resolvedTargetRoot, markers);
+  const packageJsonPath = path.join(resolvedTargetRoot, packageJsonOptions.relativePath);
+  const packageJsonValue = await readOptionalProjectJson(packageJsonPath, packageJsonOptions);
+  const context = {
+    exists: (relativePath) => pathExists(path.join(resolvedTargetRoot, relativePath)),
+    markers: markerResults,
+    packageJson: packageJsonValue,
+    packageJsonPath,
+    pathFor: (relativePath) => path.join(resolvedTargetRoot, relativePath),
+    targetRoot: resolvedTargetRoot
+  };
+  const extraInspection = await extra(context) || {};
+
+  return {
+    markers: markerResults,
+    [packageJsonOptions.key]: packageJsonValue,
+    targetRoot: resolvedTargetRoot,
+    ...extraInspection
+  };
+}
+
+class Vibe64DescribedWorkflowTargetAdapter extends Vibe64WorkflowTargetAdapter {
+  constructor({
+    commandTerminalSpecFactory = null,
+    commands = [],
+    configFields = [],
+    currentAppInspector = null,
+    defaultConfig = {},
+    id = "generic",
+    label = "Generic target",
+    projectFacts = () => ({}),
+    projectInspection = () => ({}),
+    promptContext = () => ({}),
+    promptPackRoot = "",
+    promptRenderer = null,
+    prepareWorktreeScriptPath = "",
+    runtimeContainers = () => [],
+    setupDoctorPlugins = () => [],
+    terminalToolchain = null,
+    launchTargetTerminalSpecFactory = null,
+    launchTargets = () => [],
+    targetScriptTerminalSpecFactory = null,
+    targetScriptsInspector = null,
+    workflowCommandHooks = () => ({})
+  } = {}) {
+    super({
+      commandTerminalSpecFactory,
+      commands,
+      id,
+      label,
+      prepareWorktreeScriptPath
+    });
+    this.configFields = configFields;
+    this.currentAppInspector = currentAppInspector;
+    this.defaultConfig = defaultConfig;
+    this.projectFactsFactory = projectFacts;
+    this.projectInspectionFactory = projectInspection;
+    this.promptContextFactory = promptContext;
+    this.promptRenderer = createPromptRenderer({
+      promptPackRoot,
+      promptRenderer
+    });
+    this.runtimeContainersFactory = runtimeContainers;
+    this.setupDoctorPluginsFactory = setupDoctorPlugins;
+    this.terminalToolchainFactory = terminalToolchain;
+    this.launchTargetTerminalSpecFactory = typeof launchTargetTerminalSpecFactory === "function"
+      ? launchTargetTerminalSpecFactory
+      : null;
+    this.launchTargetsFactory = launchTargets;
+    this.targetScriptTerminalSpecFactory = targetScriptTerminalSpecFactory;
+    this.targetScriptsInspector = targetScriptsInspector;
+    this.workflowCommandHooksFactory = workflowCommandHooks;
+  }
+
+  async projectInspection(targetRoot, context = {}) {
+    return this.projectInspectionFactory(targetRoot || process.cwd(), {
+      adapter: this,
+      ...context
+    });
+  }
+
+  async detect({ targetRoot } = {}) {
+    void targetRoot;
+    return adapterDetection({
+      detected: true,
+      reason: ""
+    });
+  }
+
+  async inspect({ targetRoot, ...context } = {}) {
+    return this.projectFactsFactory({
+      adapter: this,
+      ...await this.projectInspection(targetRoot || process.cwd(), context),
+      commands: this.commands,
+      config: context.config || {}
+    });
+  }
+
+  async getPromptContext({ facts = {}, targetRoot, ...context } = {}) {
+    if (facts.promptContext) {
+      return facts.promptContext;
+    }
+    return this.promptContextFactory({
+      ...await this.projectInspection(targetRoot || process.cwd(), context),
+      config: context.config || {}
+    });
+  }
+
+  async getSetupDoctorPlugins(context = {}) {
+    return resolveValue(this.setupDoctorPluginsFactory, context) || [];
+  }
+
+  async getConfigFields() {
+    return resolveValue(this.configFields) || [];
+  }
+
+  async getDefaultConfig() {
+    return resolveValue(this.defaultConfig) || {};
+  }
+
+  async getTerminalToolchainSpec(context = {}) {
+    return adapterTerminalToolchainSpec(await resolveValue(this.terminalToolchainFactory, context) || {});
+  }
+
+  async listRuntimeContainers(context = {}) {
+    const descriptors = await resolveValue(this.runtimeContainersFactory, context);
+    return Array.isArray(descriptors) ? descriptors.filter(Boolean) : [];
+  }
+
+  async getWorkflowCommandHooks(context = {}) {
+    return resolveValue(this.workflowCommandHooksFactory, context) || {};
+  }
+
+  async listLaunchTargets(context = {}) {
+    return normalizeLaunchTargets(await resolveValue(this.launchTargetsFactory, context) || []);
+  }
+
+  async createLaunchTargetTerminalSpec({
+    context = {},
+    launchTargetId = ""
+  } = {}) {
+    if (!this.launchTargetTerminalSpecFactory) {
+      return super.createLaunchTargetTerminalSpec({
+        launchTargetId
+      });
+    }
+    return this.launchTargetTerminalSpecFactory({
+      context,
+      launchTargetId,
+      session: context.session || {},
+      targetRoot: context.session?.targetRoot || context.targetRoot || ""
+    });
+  }
+
+  async renderPrompt(options = {}) {
+    if (!this.promptRenderer) {
+      return super.renderPrompt(options);
+    }
+    return this.promptRenderer.renderPrompt(options);
+  }
+
+  async inspectCurrentApp({
+    config = {},
+    includeGit = true,
+    targetRoot = ""
+  } = {}) {
+    if (!this.currentAppInspector) {
+      return super.inspectCurrentApp({
+        targetRoot
+      });
+    }
+    return this.currentAppInspector(targetRoot || process.cwd(), {
+      config,
+      includeGit
+    });
+  }
+
+  async listCurrentAppTargetScripts({
+    config = {},
+    targetRoot = ""
+  } = {}) {
+    if (!this.targetScriptsInspector) {
+      return super.listCurrentAppTargetScripts({
+        config,
+        targetRoot
+      });
+    }
+    return this.targetScriptsInspector(targetRoot || process.cwd(), {
+      config
+    });
+  }
+
+  async createCurrentAppTargetScriptTerminalSpec({
+    config = {},
+    input = {},
+    targetRoot = ""
+  } = {}) {
+    if (!this.targetScriptTerminalSpecFactory) {
+      return super.createCurrentAppTargetScriptTerminalSpec({
+        config,
+        input,
+        targetRoot
+      });
+    }
+    return this.targetScriptTerminalSpecFactory(targetRoot || process.cwd(), input, {
+      config
+    });
+  }
+}
+
+export {
+  VIBE64_WORKFLOW_COMMANDS,
+  VIBE64_WORKFLOW_SESSION_ACTION_CAPABILITIES,
+  Vibe64DescribedWorkflowTargetAdapter,
+  Vibe64WorkflowTargetAdapter,
+  vibe64WorkflowCapabilities,
+  createVibe64WorkflowCommandTerminalSpec,
+  inspectDescribedProject,
+  normalizeWorkflowCommands
+};

package/packages/vibe64-adapters/src/server/workflowCommandFacts.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+
+import {
+  shellQuote
+} from "@local/studio-terminal-core/server/shellCommands";
+
+const COMMAND_RESULT_ENV = "VIBE64_COMMAND_RESULT_FILE";
+
+function metadataFilePath(session = {}, name = "") {
+  return session.metadataRoot && name ? path.join(session.metadataRoot, name) : "";
+}
+
+function artifactFilePath(session = {}, name = "") {
+  return session.artifactsRoot && name ? path.join(session.artifactsRoot, name) : "";
+}
+
+function stepArtifactShellLibrary(session = {}, stepId = "") {
+  const quotedArtifactsRoot = shellQuote(session.artifactsRoot || "");
+  const quotedStepId = shellQuote(stepId);
+  return [
+    `VIBE64_STEP_ARTIFACTS_ROOT=${quotedArtifactsRoot}`,
+    `VIBE64_STEP_ID=${quotedStepId}`,
+    "vibe64_artifact_path() {",
+    "  printf '%s/%s.%s\\n' \"$VIBE64_STEP_ARTIFACTS_ROOT\" \"$VIBE64_STEP_ID\" \"$1\"",
+    "}",
+    "vibe64_tmp_artifact_path() {",
+    "  printf '%s/tmp/%s.%s\\n' \"$VIBE64_STEP_ARTIFACTS_ROOT\" \"$VIBE64_STEP_ID\" \"$1\"",
+    "}",
+    "vibe64_read_artifact() {",
+    "  cat \"$(vibe64_artifact_path \"$1\")\"",
+    "}",
+    "vibe64_read_tmp_artifact() {",
+    "  cat \"$(vibe64_tmp_artifact_path \"$1\")\"",
+    "}",
+    "vibe64_write_artifact() {",
+    "  mkdir -p \"$VIBE64_STEP_ARTIFACTS_ROOT\"",
+    "  printf '%s\\n' \"$2\" > \"$(vibe64_artifact_path \"$1\")\"",
+    "}",
+    "vibe64_write_tmp_artifact() {",
+    "  mkdir -p \"$VIBE64_STEP_ARTIFACTS_ROOT/tmp\"",
+    "  printf '%s\\n' \"$2\" > \"$(vibe64_tmp_artifact_path \"$1\")\"",
+    "}",
+    "vibe64_require_artifact() {",
+    "  VIBE64_REQUIRED_ARTIFACT_PATH=\"$(vibe64_artifact_path \"$1\")\"",
+    "  if [ ! -s \"$VIBE64_REQUIRED_ARTIFACT_PATH\" ]; then",
+    "    printf '[studio] Missing %s: %s\\n' \"${2:-artifact}\" \"$VIBE64_REQUIRED_ARTIFACT_PATH\" >&2",
+    "    exit 1",
+    "  fi",
+    "}",
+    "vibe64_require_tmp_artifact() {",
+    "  VIBE64_REQUIRED_ARTIFACT_PATH=\"$(vibe64_tmp_artifact_path \"$1\")\"",
+    "  if [ ! -s \"$VIBE64_REQUIRED_ARTIFACT_PATH\" ]; then",
+    "    printf '[studio] Missing %s: %s\\n' \"${2:-temporary artifact}\" \"$VIBE64_REQUIRED_ARTIFACT_PATH\" >&2",
+    "    exit 1",
+    "  fi",
+    "}"
+  ].join("\n");
+}
+
+function requiredCommandFileScript(filePath = "", label = "file") {
+  const quotedFilePath = shellQuote(filePath);
+  return [
+    `if [ ! -s ${quotedFilePath} ]; then`,
+    `  printf '[studio] Missing ${label}: %s\\n' ${quotedFilePath} >&2`,
+    "  exit 1",
+    "fi"
+  ].join("\n");
+}
+
+function requiredArtifactScript(session = {}, name = "", label = "artifact") {
+  return requiredCommandFileScript(artifactFilePath(session, name), label);
+}
+
+function recordCommandFactScript(name = "", valueExpression = "") {
+  return [
+    `VIBE64_COMMAND_FACT_VALUE=${valueExpression}`,
+    `if [ -n "\${${COMMAND_RESULT_ENV}:-}" ]; then`,
+    `  printf 'fact:set\\t%s\\t%s\\n' ${shellQuote(name)} "$(printf '%s' "$VIBE64_COMMAND_FACT_VALUE" | base64 | tr -d '\\n')" >> "$${COMMAND_RESULT_ENV}"`,
+    "fi"
+  ].join("\n");
+}
+
+export {
+  artifactFilePath,
+  metadataFilePath,
+  recordCommandFactScript,
+  requiredArtifactScript,
+  requiredCommandFileScript,
+  stepArtifactShellLibrary
+};