dxcomplete 0.2.1 → 0.2.2

package/src/runtime/workspace.ts

@@ -1,155 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import { access, readFile } from "node:fs/promises";
-import path from "node:path";
-import { normalizeEmail } from "./actor.js";
-
-export type WorkspaceBootstrapMember = {
-  email: string;
-  roles: WorkspaceBootstrapRole[];
-  role?: "owner" | "member";
-};
-
-export type WorkspaceConfig = {
-  workspaceId: string;
-  name: string;
-  mode?: WorkspaceMode;
-  bootstrapMembers: WorkspaceBootstrapMember[];
-};
-
-export type WorkspaceMode = "transformation" | "greenfield" | "limited-disclosure";
-export type WorkspaceBootstrapRole = "owner" | "engineer" | "tester" | "operator" | "support_agent" | "end_user";
-
-export type WorkspaceConfigOptions = {
-  cwd?: string;
-  configPath?: string;
-};
-
-const DEFAULT_WORKSPACE_CONFIG = path.join("dxcomplete", "workspace.json");
-
-export async function loadWorkspaceConfig(options: WorkspaceConfigOptions = {}): Promise<WorkspaceConfig> {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const configPath = path.resolve(cwd, options.configPath ?? DEFAULT_WORKSPACE_CONFIG);
-
-  if (!(await fileExists(configPath))) {
-    throw new Error(`DX Complete workspace config not found: ${configPath}`);
-  }
-
-  const parsed = JSON.parse(await readFile(configPath, "utf8")) as unknown;
-  return parseWorkspaceConfig(parsed, configPath);
-}
-
-export function parseWorkspaceConfig(value: unknown, source = "workspace config"): WorkspaceConfig {
-  if (!value || typeof value !== "object") {
-    throw new Error(`${source} must be a JSON object.`);
-  }
-
-  const input = value as Record<string, unknown>;
-  const workspaceId = readRequiredString(input.workspaceId, "workspaceId", source);
-  const name = readRequiredString(input.name, "name", source);
-  const mode = parseWorkspaceMode(input.mode, source);
-  const bootstrapMembers = parseBootstrapMembers(input.bootstrapMembers, source);
-
-  return {
-    workspaceId,
-    name,
-    ...(mode ? { mode } : {}),
-    bootstrapMembers
-  };
-}
-
-function parseWorkspaceMode(value: unknown, source: string): WorkspaceMode | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  if (value === "transformation" || value === "greenfield" || value === "limited-disclosure") {
-    return value;
-  }
-
-  throw new Error(`${source} mode must be transformation, greenfield, or limited-disclosure when provided.`);
-}
-
-function parseBootstrapMembers(value: unknown, source: string): WorkspaceBootstrapMember[] {
-  if (value === undefined) {
-    return [];
-  }
-
-  if (!Array.isArray(value)) {
-    throw new Error(`${source} bootstrapMembers must be an array when provided.`);
-  }
-
-  return value.map((entry, index) => {
-    if (!entry || typeof entry !== "object") {
-      throw new Error(`${source} bootstrapMembers[${index}] must be an object.`);
-    }
-
-    const record = entry as Record<string, unknown>;
-    const email = normalizeEmail(readRequiredString(record.email, `bootstrapMembers[${index}].email`, source));
-    const roles = parseBootstrapMemberRoles(record, `bootstrapMembers[${index}]`, source);
-
-    return { email, roles };
-  });
-}
-
-function parseBootstrapMemberRoles(
-  record: Record<string, unknown>,
-  keyPrefix: string,
-  source: string
-): WorkspaceBootstrapRole[] {
-  if (Array.isArray(record.roles)) {
-    const roles = record.roles.map((role, roleIndex) =>
-      parseBootstrapRole(role, `${keyPrefix}.roles[${roleIndex}]`, source)
-    );
-    return uniqueRoles(roles);
-  }
-
-  if (record.role === "owner") {
-    return ["owner"];
-  }
-
-  if (record.role === "member") {
-    return ["end_user"];
-  }
-
-  throw new Error(`${source} ${keyPrefix}.roles must contain at least one valid workspace role.`);
-}
-
-function parseBootstrapRole(value: unknown, key: string, source: string): WorkspaceBootstrapRole {
-  if (
-    value === "owner" ||
-    value === "engineer" ||
-    value === "tester" ||
-    value === "operator" ||
-    value === "support_agent" ||
-    value === "end_user"
-  ) {
-    return value;
-  }
-
-  throw new Error(`${source} ${key} must be owner, engineer, tester, operator, support_agent, or end_user.`);
-}
-
-function uniqueRoles(roles: WorkspaceBootstrapRole[]): WorkspaceBootstrapRole[] {
-  const unique = [...new Set(roles)];
-  if (unique.length === 0) {
-    throw new Error("workspace config bootstrap member roles must contain at least one role.");
-  }
-  return unique.sort();
-}
-
-function readRequiredString(value: unknown, key: string, source: string): string {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${source} ${key} must be a non-empty string.`);
-  }
-
-  return value.trim();
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath, fsConstants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/upgrade.ts

@@ -1,356 +0,0 @@
-import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import {
-  INSTALL_MANIFEST_SCHEMA_VERSION,
-  INSTALL_MANIFEST_PATH,
-  type InstallManifest,
-  type UpgradeManagedFile,
-  hashContent,
-  hashFile,
-  readInstallManifest,
-  writeInstallManifest
-} from "./install-manifest.js";
-import { fileExists, resolvePackageRoot } from "./package-root.js";
-import {
-  DXCOMPLETE_PACKAGE_VERSION,
-  WORKSPACE_COMPATIBILITY_VERSION
-} from "./version.js";
-
-export type UpgradeOptions = {
-  targetDir: string;
-  apply?: boolean;
-  force?: boolean;
-};
-
-export type UpgradeResult = {
-  targetDir: string;
-  applied: boolean;
-  packageVersion: string;
-  workspaceCompatibility: number;
-  written: string[];
-  planned: string[];
-  unchanged: string[];
-  manualReview: string[];
-  userOwnedDrift: string[];
-  manifestWritten: boolean;
-};
-
-const WELL_KNOWN_REWRITES = [
-  {
-    source: "/.well-known/oauth-authorization-server",
-    destination: "/api/dxcomplete/.well-known/oauth-authorization-server"
-  },
-  {
-    source: "/.well-known/oauth-protected-resource/api/mcp",
-    destination: "/api/dxcomplete/.well-known/oauth-protected-resource/api/mcp"
-  }
-];
-const WORKSPACE_CONFIG_PATH = path.join("dxcomplete", "workspace.json");
-
-export async function upgradeProject(options: UpgradeOptions): Promise<UpgradeResult> {
-  const targetDir = path.resolve(options.targetDir);
-  const apply = options.apply ?? false;
-  const force = options.force ?? false;
-  await assertExistingDxcompleteInstall(targetDir);
-  const packageRoot = await resolvePackageRoot();
-  const managedFiles = getUpgradeManagedFiles(packageRoot, targetDir);
-  const manifest = await readInstallManifest(targetDir);
-  const result: UpgradeResult = {
-    targetDir,
-    applied: apply,
-    packageVersion: DXCOMPLETE_PACKAGE_VERSION,
-    workspaceCompatibility: WORKSPACE_COMPATIBILITY_VERSION,
-    written: [],
-    planned: [],
-    unchanged: [],
-    manualReview: [],
-    userOwnedDrift: [],
-    manifestWritten: false
-  };
-
-  if (apply) {
-    const preview = await upgradeProject({ targetDir, apply: false, force });
-    if (preview.manualReview.length > 0) {
-      return {
-        ...preview,
-        applied: true,
-        written: [],
-        planned: [],
-        manifestWritten: false
-      };
-    }
-  }
-
-  for (const file of managedFiles) {
-    if (file.strategy === "merge-vercel") {
-      await upgradeVercelConfig(file, { apply, force, manifest }, result);
-      continue;
-    }
-
-    await upgradeCopiedFile(file, { apply, force, manifest }, result);
-  }
-
-  result.userOwnedDrift.push(...(await collectUserOwnedDrift(packageRoot, targetDir)));
-
-  const manifestNeedsWrite =
-    result.planned.length > 0 || result.written.length > 0 || shouldWriteManifest(manifest, managedFiles);
-
-  if (apply && result.manualReview.length === 0 && manifestNeedsWrite) {
-    await writeInstallManifest(targetDir, managedFiles);
-    result.written.push(INSTALL_MANIFEST_PATH);
-    result.manifestWritten = true;
-  } else if (!apply && manifestNeedsWrite) {
-    result.planned.push(INSTALL_MANIFEST_PATH);
-  }
-
-  return result;
-}
-
-async function assertExistingDxcompleteInstall(targetDir: string): Promise<void> {
-  if (await fileExists(path.join(targetDir, WORKSPACE_CONFIG_PATH))) {
-    return;
-  }
-
-  throw new Error(
-    `DX Complete install not found in ${targetDir}. Run dxcomplete init before dxcomplete upgrade.`
-  );
-}
-
-function shouldWriteManifest(manifest: InstallManifest | undefined, files: UpgradeManagedFile[]): boolean {
-  if (!manifest) {
-    return true;
-  }
-
-  if (
-    manifest.schemaVersion !== INSTALL_MANIFEST_SCHEMA_VERSION ||
-    manifest.packageVersion !== DXCOMPLETE_PACKAGE_VERSION ||
-    manifest.workspaceCompatibility !== WORKSPACE_COMPATIBILITY_VERSION
-  ) {
-    return true;
-  }
-
-  return files.some((file) => !manifest.managedFiles[file.destinationRelative]);
-}
-
-export function getUpgradeManagedFiles(packageRoot: string, targetDir: string): UpgradeManagedFile[] {
-  const files = [
-    {
-      sourceRelative: path.join("templates", "next", "pages", "api", "mcp.js"),
-      destinationRelative: path.join("pages", "api", "mcp.js"),
-      strategy: "copy" as const
-    },
-    {
-      sourceRelative: path.join("templates", "next", "pages", "api", "dxcomplete.js"),
-      destinationRelative: path.join("pages", "api", "dxcomplete.js"),
-      strategy: "copy" as const
-    },
-    {
-      sourceRelative: path.join("templates", "next", "pages", "api", "dxcomplete", "[...path].js"),
-      destinationRelative: path.join("pages", "api", "dxcomplete", "[...path].js"),
-      strategy: "copy" as const
-    },
-    {
-      sourceRelative: path.join("templates", "next", "pages", "api", "auth", "callback", "google.js"),
-      destinationRelative: path.join("pages", "api", "auth", "callback", "google.js"),
-      strategy: "copy" as const
-    },
-    {
-      sourceRelative: path.join("templates", "next", "vercel.json"),
-      destinationRelative: "vercel.json",
-      strategy: "merge-vercel" as const
-    }
-  ];
-
-  return files.map((file) => ({
-    ...file,
-    sourcePath: path.join(packageRoot, file.sourceRelative),
-    destinationPath: path.join(targetDir, file.destinationRelative)
-  }));
-}
-
-async function upgradeCopiedFile(
-  file: UpgradeManagedFile,
-  options: {
-    apply: boolean;
-    force: boolean;
-    manifest: InstallManifest | undefined;
-  },
-  result: UpgradeResult
-): Promise<void> {
-  const desiredHash = await hashFile(file.sourcePath);
-  const exists = await fileExists(file.destinationPath);
-  const currentHash = exists ? await hashFile(file.destinationPath) : undefined;
-
-  if (currentHash === desiredHash) {
-    result.unchanged.push(file.destinationRelative);
-    return;
-  }
-
-  const previousHash = options.manifest?.managedFiles[file.destinationRelative]?.sha256;
-  if (exists && !options.force && currentHash !== previousHash) {
-    result.manualReview.push(
-      previousHash
-        ? `${file.destinationRelative} (modified since last DX Complete install)`
-        : `${file.destinationRelative} (differs from the current scaffold and no install manifest is available)`
-    );
-    return;
-  }
-
-  if (!options.apply) {
-    result.planned.push(file.destinationRelative);
-    return;
-  }
-
-  await mkdir(path.dirname(file.destinationPath), { recursive: true });
-  await copyFile(file.sourcePath, file.destinationPath);
-  result.written.push(file.destinationRelative);
-}
-
-async function upgradeVercelConfig(
-  file: UpgradeManagedFile,
-  options: {
-    apply: boolean;
-    force: boolean;
-    manifest: InstallManifest | undefined;
-  },
-  result: UpgradeResult
-): Promise<void> {
-  const exists = await fileExists(file.destinationPath);
-  const templateContent = await readFile(file.sourcePath, "utf8");
-  let desiredContent = templateContent;
-
-  if (exists) {
-    const currentContent = await readFile(file.destinationPath, "utf8");
-    try {
-      desiredContent = `${JSON.stringify(mergeVercelConfig(JSON.parse(currentContent)), null, 2)}\n`;
-    } catch {
-      if (!options.force) {
-        result.manualReview.push(`${file.destinationRelative} (invalid JSON; cannot merge safely)`);
-        return;
-      }
-    }
-
-    if (hashContent(currentContent) === hashContent(desiredContent)) {
-      result.unchanged.push(file.destinationRelative);
-      return;
-    }
-  }
-
-  if (!options.apply) {
-    result.planned.push(file.destinationRelative);
-    return;
-  }
-
-  await writeFile(file.destinationPath, desiredContent, "utf8");
-  result.written.push(file.destinationRelative);
-}
-
-function mergeVercelConfig(value: unknown): Record<string, unknown> {
-  const config = isPlainObject(value) ? { ...value } : {};
-  const functions = isPlainObject(config.functions) ? { ...config.functions } : {};
-  const pagesFunctionKey = "pages/api/**/*.js";
-  const pagesFunction = isPlainObject(functions[pagesFunctionKey])
-    ? { ...functions[pagesFunctionKey] }
-    : {};
-
-  pagesFunction.includeFiles = mergeIncludeFiles(pagesFunction.includeFiles, "dxcomplete/workspace.json");
-  functions[pagesFunctionKey] = pagesFunction;
-  config.functions = functions;
-  config.rewrites = mergeRewrites(config.rewrites);
-
-  return config;
-}
-
-function mergeIncludeFiles(value: unknown, requiredFile: string): string | string[] {
-  if (typeof value === "string") {
-    return value === requiredFile ? value : uniqueStrings([value, requiredFile]);
-  }
-
-  if (Array.isArray(value)) {
-    return uniqueStrings([...value.filter((entry): entry is string => typeof entry === "string"), requiredFile]);
-  }
-
-  return requiredFile;
-}
-
-function mergeRewrites(value: unknown): Record<string, unknown>[] {
-  const rewrites = Array.isArray(value)
-    ? value.filter((entry): entry is Record<string, unknown> => isPlainObject(entry)).map((entry) => ({ ...entry }))
-    : [];
-
-  for (const requiredRewrite of WELL_KNOWN_REWRITES) {
-    const existing = rewrites.find((rewrite) => rewrite.source === requiredRewrite.source);
-    if (existing) {
-      existing.destination = requiredRewrite.destination;
-    } else {
-      rewrites.push({ ...requiredRewrite });
-    }
-  }
-
-  return rewrites;
-}
-
-async function collectUserOwnedDrift(packageRoot: string, targetDir: string): Promise<string[]> {
-  const files = [
-    ...(await collectTemplateFiles(
-      path.join(packageRoot, "docs"),
-      path.join(targetDir, "dxcomplete", "docs"),
-      path.join("dxcomplete", "docs")
-    )),
-    ...(await collectTemplateFiles(
-      path.join(packageRoot, "templates", "process"),
-      path.join(targetDir, "dxcomplete", "process"),
-      path.join("dxcomplete", "process")
-    ))
-  ];
-  const drift: string[] = [];
-
-  for (const file of files) {
-    if (!(await fileExists(file.destinationPath))) {
-      drift.push(`${file.destinationRelative} (missing user-owned scaffold file)`);
-      continue;
-    }
-
-    if ((await hashFile(file.sourcePath)) !== (await hashFile(file.destinationPath))) {
-      drift.push(`${file.destinationRelative} (differs from current package template)`);
-    }
-  }
-
-  return drift;
-}
-
-async function collectTemplateFiles(
-  sourceDir: string,
-  destinationDir: string,
-  destinationRootRelative: string
-): Promise<Array<{ sourcePath: string; destinationPath: string; destinationRelative: string }>> {
-  const entries = await readdir(sourceDir, { withFileTypes: true });
-  const files: Array<{ sourcePath: string; destinationPath: string; destinationRelative: string }> = [];
-
-  for (const entry of entries) {
-    const sourcePath = path.join(sourceDir, entry.name);
-    const destinationPath = path.join(destinationDir, entry.name);
-    const destinationRelative = path.join(destinationRootRelative, entry.name);
-
-    if (entry.isDirectory()) {
-      files.push(...(await collectTemplateFiles(sourcePath, destinationPath, destinationRelative)));
-      continue;
-    }
-
-    if (!entry.isFile()) {
-      continue;
-    }
-
-    files.push({ sourcePath, destinationPath, destinationRelative });
-  }
-
-  return files;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function uniqueStrings(values: string[]): string[] {
-  return [...new Set(values)];
-}

package/src/validate.ts

@@ -1,141 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import { access } from "node:fs/promises";
-import path from "node:path";
-
-export type ValidateOptions = {
-  targetDir: string;
-  packageLayout?: boolean;
-};
-
-export type ValidateResult = {
-  targetDir: string;
-  ok: boolean;
-  missing: string[];
-};
-
-const docs = [
-  "index.md",
-  "decision-basis.md",
-  "cost-model.md",
-  "glossary.md",
-  "model.md",
-  "operating-guide.md",
-  "roles.md",
-  "taxonomy.md",
-  "workflows.md",
-  "diagrams.md",
-  "codex-integration.md",
-  "open-questions.md"
-];
-
-const processFiles = [
-  "README.md",
-  "decision-basis.yml",
-  "cost-model.yml",
-  "roles.yml",
-  "taxonomy.yml",
-  "workflows.yml",
-  "controls.yml"
-];
-
-const diagrams = [
-  "00-decision-basis.mmd",
-  "00-overview.mmd",
-  "01-intake-triage.mmd",
-  "02-product-definition.mmd",
-  "03-engineering-execution.mmd",
-  "04-qa-verification.mmd",
-  "05-product-validation.mmd",
-  "06-change-release-control.mmd",
-  "07-deployment-operations.mmd",
-  "08-support-incident-management.mmd",
-  "09-problem-improvement.mmd",
-  "10-risk-control-management.mmd",
-  "11-audit-evidence-capture.mmd"
-];
-
-export async function validateScaffold(options: ValidateOptions): Promise<ValidateResult> {
-  const targetDir = path.resolve(options.targetDir);
-  const requiredFiles = options.packageLayout
-    ? packageRequiredFiles()
-    : installedRequiredFiles();
-
-  const missing: string[] = [];
-
-  for (const requiredFile of requiredFiles) {
-    if (!(await fileExists(path.join(targetDir, requiredFile)))) {
-      missing.push(requiredFile);
-    }
-  }
-
-  return {
-    targetDir,
-    ok: missing.length === 0,
-    missing
-  };
-}
-
-function packageRequiredFiles(): string[] {
-  return [
-    ...docs.map((file) => path.join("docs", file)),
-    ...processFiles.map((file) => path.join("templates", "process", file)),
-    ...diagrams.map((file) => path.join("templates", "process", "diagrams", file)),
-    ".env.example",
-    path.join("api", "mcp.js"),
-    path.join("api", "dxcomplete.js"),
-    path.join("api", "dxcomplete-service.js"),
-    path.join("api", "auth", "callback", "google.js"),
-    path.join("dxcomplete", "workspace.json"),
-    path.join("templates", "AGENTS.md"),
-    path.join("scripts", "check-env-surface.mjs"),
-    path.join("scripts", "smoke-mcp-http.mjs"),
-    path.join("scripts", "runtime-work-order.mjs"),
-    path.join("scripts", "check-public-copy.mjs"),
-    path.join("scripts", "check-service-boundary.mjs"),
-    path.join("templates", "next", "pages", "api", "mcp.js"),
-    path.join("templates", "next", "pages", "api", "dxcomplete.js"),
-    path.join("templates", "next", "pages", "api", "dxcomplete", "[...path].js"),
-    path.join("templates", "next", "pages", "api", "auth", "callback", "google.js"),
-    path.join("templates", "next", "vercel.json"),
-    path.join("templates", "github", "workflows", "dxcomplete.yml"),
-    path.join("src", "cli.ts"),
-    path.join("src", "install-manifest.ts"),
-    path.join("src", "init.ts"),
-    path.join("src", "package-root.ts"),
-    path.join("src", "http", "server.ts"),
-    path.join("src", "http", "service.ts"),
-    path.join("src", "mcp", "server.ts"),
-    path.join("src", "runtime", "auth.ts"),
-    path.join("src", "runtime", "check.ts"),
-    path.join("src", "runtime", "config.ts"),
-    path.join("src", "runtime", "mongo.ts"),
-    path.join("src", "runtime", "records.ts"),
-    path.join("src", "runtime", "workspace.ts"),
-    path.join("src", "upgrade.ts"),
-    path.join("src", "version.ts"),
-    path.join("src", "validate.ts")
-  ];
-}
-
-function installedRequiredFiles(): string[] {
-  return [
-    path.join("pages", "api", "mcp.js"),
-    path.join("pages", "api", "dxcomplete.js"),
-    path.join("pages", "api", "dxcomplete", "[...path].js"),
-    path.join("pages", "api", "auth", "callback", "google.js"),
-    "vercel.json",
-    path.join("dxcomplete", "workspace.json"),
-    ...docs.map((file) => path.join("dxcomplete", "docs", file)),
-    ...processFiles.map((file) => path.join("dxcomplete", "process", file)),
-    ...diagrams.map((file) => path.join("dxcomplete", "process", "diagrams", file))
-  ];
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath, fsConstants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/version.ts

@@ -1,16 +0,0 @@
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const packageJson = require("../package.json") as { version?: unknown };
-
-export const DXCOMPLETE_PACKAGE_VERSION = readPackageVersion(packageJson.version);
-export const WORKSPACE_COMPATIBILITY_VERSION = 1;
-export const MCP_SURFACE_ID = "dxc-mcp-surface";
-
-function readPackageVersion(value: unknown): string {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error("DX Complete package.json version must be a non-empty string.");
-  }
-
-  return value;
-}