@aiworkbench/vibe-publish 0.0.2 → 0.0.5

package/dist/index.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "node:util";
+
+// src/config.ts
+import { readFileSync } from "node:fs";
+import { resolve, parse as parsePath } from "node:path";
+function loadDotenv(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  const { root } = parsePath(dir);
+  while (dir !== root) {
+    try {
+      const raw = readFileSync(resolve(dir, ".env"), "utf-8");
+      for (const line of raw.split(`
+`)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+          continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+          continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        if (process.env[key] === undefined) {
+          process.env[key] = value;
+        }
+      }
+      return;
+    } catch {
+      dir = resolve(dir, "..");
+    }
+  }
+}
+function envScoped(key, environment) {
+  const scoped = process.env[`${key}_${environment.toUpperCase()}`];
+  if (scoped)
+    return scoped;
+  return process.env[key];
+}
+function loadConfig(overrides = {}) {
+  loadDotenv();
+  const env = overrides.environment ?? process.env.VIBE_ENVIRONMENT ?? "dev";
+  return {
+    environment: env,
+    directPush: overrides.directPush ?? process.env.VIBE_DIRECT_PUSH === "true",
+    storageProvider: overrides.storageProvider ?? process.env.VIBE_STORAGE_PROVIDER ?? "azure-blob",
+    azureAccountName: overrides.azureAccountName ?? envScoped("VIBE_STORAGE_ACCOUNT_NAME", env),
+    azureAccountKey: overrides.azureAccountKey ?? envScoped("VIBE_STORAGE_ACCOUNT_KEY", env),
+    azureContainerName: overrides.azureContainerName ?? envScoped("VIBE_STORAGE_CONTAINER_NAME", env),
+    gitPlatform: overrides.gitPlatform ?? process.env.VIBE_GIT_PLATFORM ?? "github",
+    registryRepo: overrides.registryRepo ?? envScoped("VIBE_REGISTRY_REPO", env),
+    registryToken: overrides.registryToken ?? envScoped("VIBE_REGISTRY_TOKEN", env),
+    githubApiUrl: overrides.githubApiUrl ?? (process.env.VIBE_GITHUB_API_URL || undefined) ?? (process.env.GITHUB_API_URL || undefined) ?? "https://api.github.com",
+    githubServerUrl: overrides.githubServerUrl ?? (process.env.VIBE_GITHUB_SERVER_URL || undefined) ?? (process.env.GITHUB_SERVER_URL || undefined) ?? "https://github.com",
+    publishedBy: overrides.publishedBy ?? process.env.GITHUB_ACTOR ?? process.env.USER ?? "unknown"
+  };
+}
+
+// src/publish.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/integrity.ts
+import { createHash } from "node:crypto";
+function computeIntegrity(content) {
+  const hash = createHash("sha384").update(content).digest("base64");
+  return `sha384-${hash}`;
+}
+
+// src/storage/azure-blob.ts
+import {
+  BlobServiceClient,
+  StorageSharedKeyCredential
+} from "@azure/storage-blob";
+
+class AzureBlobProvider {
+  client;
+  containerName;
+  accountName;
+  constructor(config) {
+    this.accountName = config.accountName;
+    this.containerName = config.containerName;
+    const credential = new StorageSharedKeyCredential(config.accountName, config.accountKey);
+    this.client = new BlobServiceClient(`https://${config.accountName}.blob.core.windows.net`, credential);
+  }
+  getUrl(appId, version, filename) {
+    return `https://${this.accountName}.blob.core.windows.net/${this.containerName}/${appId}/${version}/${filename}`;
+  }
+  async exists(appId, version, filename) {
+    const container = this.client.getContainerClient(this.containerName);
+    const blob = container.getBlockBlobClient(`${appId}/${version}/${filename}`);
+    return blob.exists();
+  }
+  async upload(appId, version, filename, content, contentType) {
+    const container = this.client.getContainerClient(this.containerName);
+    const blob = container.getBlockBlobClient(`${appId}/${version}/${filename}`);
+    await blob.upload(content, content.length, {
+      blobHTTPHeaders: {
+        blobContentType: contentType,
+        blobCacheControl: "public, max-age=31536000, immutable"
+      }
+    });
+    return {
+      url: this.getUrl(appId, version, filename),
+      sizeBytes: content.length
+    };
+  }
+}
+
+// src/storage/index.ts
+function resolveStorageProvider(config) {
+  switch (config.storageProvider) {
+    case "azure-blob":
+      if (!config.azureAccountName || !config.azureAccountKey || !config.azureContainerName) {
+        throw new Error("Azure Blob requires VIBE_STORAGE_ACCOUNT_NAME, VIBE_STORAGE_ACCOUNT_KEY, and VIBE_STORAGE_CONTAINER_NAME");
+      }
+      return new AzureBlobProvider({
+        accountName: config.azureAccountName,
+        accountKey: config.azureAccountKey,
+        containerName: config.azureContainerName
+      });
+    case "s3":
+      throw new Error('S3 provider is not yet implemented. Set VIBE_STORAGE_PROVIDER="azure-blob" or implement S3Provider.');
+    case "gcs":
+      throw new Error('GCS provider is not yet implemented. Set VIBE_STORAGE_PROVIDER="azure-blob" or implement GCSProvider.');
+    default:
+      throw new Error(`Unknown storage provider: "${config.storageProvider}". Supported: azure-blob, s3, gcs`);
+  }
+}
+
+// src/git-platform/github.ts
+import { execFileSync } from "node:child_process";
+
+class GitHubAdapter {
+  repo;
+  token;
+  apiUrl;
+  serverUrl;
+  hostname;
+  constructor(config) {
+    this.repo = config.registryRepo;
+    this.token = config.token;
+    this.apiUrl = config.apiUrl;
+    this.serverUrl = config.serverUrl;
+    this.hostname = new URL(config.serverUrl).hostname;
+  }
+  cloneUrl() {
+    return `https://x-access-token:${this.token}@${this.hostname}/${this.repo}.git`;
+  }
+  redact(text) {
+    return this.token ? text.replaceAll(this.token, "***") : text;
+  }
+  git(args, cwd) {
+    try {
+      return execFileSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(this.redact(msg));
+    }
+  }
+  async cloneRegistry(targetDir) {
+    try {
+      execFileSync("git", ["clone", "--depth", "1", this.cloneUrl(), targetDir], { stdio: ["pipe", "pipe", "pipe"] });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(this.redact(msg));
+    }
+    this.git(["config", "user.name", "vibe-publish[bot]"], targetDir);
+    this.git(["config", "user.email", `vibe-publish[bot]@users.noreply.${this.hostname}`], targetDir);
+    return targetDir;
+  }
+  async createPullRequest(opts) {
+    const { repoDir, branchName, title, body, baseBranch, filesToAdd } = opts;
+    this.git(["checkout", "-b", branchName], repoDir);
+    for (const file of filesToAdd) {
+      this.git(["add", file], repoDir);
+    }
+    this.git(["commit", "-m", title], repoDir);
+    this.git(["push", "origin", branchName], repoDir);
+    const apiUrl = `${this.apiUrl}/repos/${this.repo}/pulls`;
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        title,
+        body,
+        head: branchName,
+        base: baseBranch
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to create PR: ${response.status} ${text}`);
+    }
+    const pr = await response.json();
+    return { url: pr.html_url, number: pr.number };
+  }
+  async pushDirectly(opts) {
+    const { repoDir, branchName, commitMessage, filesToAdd } = opts;
+    for (const file of filesToAdd) {
+      this.git(["add", file], repoDir);
+    }
+    this.git(["commit", "-m", commitMessage], repoDir);
+    this.git(["push", "origin", branchName], repoDir);
+  }
+}
+
+// src/git-platform/index.ts
+function resolveGitPlatform(config) {
+  switch (config.gitPlatform) {
+    case "github":
+      if (!config.registryRepo || !config.registryToken) {
+        throw new Error("GitHub requires VIBE_REGISTRY_REPO and VIBE_REGISTRY_TOKEN");
+      }
+      return new GitHubAdapter({
+        registryRepo: config.registryRepo,
+        token: config.registryToken,
+        apiUrl: config.githubApiUrl,
+        serverUrl: config.githubServerUrl
+      });
+    case "azure-devops":
+      throw new Error('Azure DevOps adapter is not yet implemented. Set VIBE_GIT_PLATFORM="github" or implement AzureDevOpsAdapter.');
+    case "gitlab":
+      throw new Error('GitLab adapter is not yet implemented. Set VIBE_GIT_PLATFORM="github" or implement GitLabAdapter.');
+    default:
+      throw new Error(`Unknown git platform: "${config.gitPlatform}". Supported: github, azure-devops, gitlab`);
+  }
+}
+
+// src/registry.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+async function updateRegistry(opts) {
+  const { entry, environment, directPush, git } = opts;
+  const tmpBase = join(tmpdir(), `vibe-registry-${randomBytes(4).toString("hex")}`);
+  mkdirSync(tmpBase, { recursive: true });
+  const repoDir = await git.cloneRegistry(tmpBase);
+  const appsFile = join(repoDir, environment, "apps.json");
+  let apps;
+  try {
+    apps = JSON.parse(readFileSync2(appsFile, "utf-8"));
+  } catch {
+    apps = [];
+  }
+  const existingIdx = apps.findIndex((a) => a.id === entry.id);
+  if (existingIdx !== -1) {
+    apps[existingIdx] = entry;
+  } else {
+    apps.push(entry);
+  }
+  apps.sort((a, b) => a.id.localeCompare(b.id));
+  writeFileSync(appsFile, JSON.stringify(apps, null, 2) + `
+`);
+  const relPath = `${environment}/apps.json`;
+  if (directPush) {
+    await git.pushDirectly({
+      repoDir,
+      branchName: "main",
+      commitMessage: `publish: ${entry.id} v${entry.version} → ${environment}`,
+      filesToAdd: [relPath]
+    });
+    return { method: "push" };
+  }
+  const branchName = `publish/${environment}/${entry.id}-${entry.version}`;
+  const pr = await git.createPullRequest({
+    repoDir,
+    branchName,
+    title: `publish: ${entry.id} v${entry.version} → ${environment}`,
+    body: [
+      `## Publish ${entry.id} v${entry.version}`,
+      "",
+      `| Field | Value |`,
+      `|---|---|`,
+      `| **Environment** | ${environment} |`,
+      `| **Bundle URL** | ${entry.bundleUrl} |`,
+      `| **Integrity** | \`${entry.integrity.slice(0, 20)}…\` |`,
+      `| **Published by** | ${entry.publishedBy} |`
+    ].join(`
+`),
+    baseBranch: "main",
+    filesToAdd: [relPath]
+  });
+  return { method: "pr", url: pr.url };
+}
+
+// src/publish.ts
+async function publish(appDir, config) {
+  const manifestPath = resolve2(appDir, "manifest.json");
+  const bundlePath = resolve2(appDir, "dist/index.js");
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch {
+    throw new Error(`Cannot read manifest.json at ${manifestPath}`);
+  }
+  let bundleContent;
+  try {
+    bundleContent = readFileSync3(bundlePath);
+  } catch {
+    throw new Error(`Cannot read dist/index.js at ${bundlePath}. Did you run "bun run build"?`);
+  }
+  const { id, version } = manifest;
+  console.log(`Publishing ${id} v${version} → ${config.environment}`);
+  const integrity = computeIntegrity(bundleContent);
+  const storage = resolveStorageProvider(config);
+  const alreadyExists = await storage.exists(id, version, "index.js");
+  if (alreadyExists) {
+    throw new Error(`Immutability violation: ${id}/${version}/index.js already exists in storage. ` + `Bump the version in manifest.json to publish a new release.`);
+  }
+  console.log(`Uploading ${id}/${version}/index.js…`);
+  const { url: bundleUrl, sizeBytes } = await storage.upload(id, version, "index.js", bundleContent, "application/javascript");
+  console.log(`Uploaded: ${bundleUrl} (${sizeBytes} bytes)`);
+  const entry = {
+    ...manifest,
+    bundleUrl,
+    integrity,
+    bundleSizeBytes: sizeBytes,
+    publishedAt: new Date().toISOString(),
+    publishedBy: config.publishedBy
+  };
+  console.log(`Updating registry (${config.environment})…`);
+  const git = resolveGitPlatform(config);
+  const result = await updateRegistry({
+    entry,
+    environment: config.environment,
+    directPush: config.directPush,
+    git
+  });
+  if (result.method === "pr") {
+    console.log(`PR created: ${result.url}`);
+  } else {
+    console.log(`Pushed directly to main`);
+  }
+  return {
+    entry,
+    registryMethod: result.method,
+    prUrl: result.url
+  };
+}
+
+// src/index.ts
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      environment: { type: "string", short: "e" },
+      "direct-push": { type: "boolean", default: false },
+      "app-dir": { type: "string", default: "." },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    console.log(`
+Usage: vibe-publish [options]
+
+Options:
+  -e, --environment <env>  Target environment: dev, staging, prod (default: dev)
+  --direct-push            Push directly to main instead of opening a PR
+  --app-dir <path>         Path to the mini-app directory (default: .)
+  -h, --help               Show this help
+    `.trim());
+    process.exit(0);
+  }
+  const config = loadConfig({
+    environment: values.environment,
+    directPush: values["direct-push"] || undefined
+  });
+  const appDir = values["app-dir"] ?? process.cwd();
+  try {
+    const result = await publish(appDir, config);
+    console.log(`
+Done. ${result.entry.id} v${result.entry.version} published.`);
+  } catch (err) {
+    console.error(`
+Publish failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiworkbench/vibe-publish",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "publishConfig": { "access": "public" },
   "type": "module",
   "bin": {
@@ -9,7 +9,6 @@
   "main": "dist/index.js",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     }
   },
@@ -18,15 +17,16 @@
     "dev": "bun --watch src/index.ts",
     "test": "bun test",
     "type-check": "tsc --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@aiworkbench/vibe-types": "^0.0.2",
+    "@aiworkbench/vibe-types": "^0.0.4",
     "@azure/storage-blob": "^12.25.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
   },
-  "files": ["dist", "src"]
+  "files": ["dist"]
 }

package/src/__tests__/config.test.ts

@@ -1,87 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { loadConfig } from "../config.js";
-
-describe("loadConfig — GitHub URL resolution", () => {
-  const envBackup: Record<string, string | undefined> = {};
-  const envKeys = [
-    "VIBE_GITHUB_API_URL",
-    "VIBE_GITHUB_SERVER_URL",
-    "GITHUB_API_URL",
-    "GITHUB_SERVER_URL",
-  ];
-
-  beforeEach(() => {
-    for (const key of envKeys) {
-      envBackup[key] = process.env[key];
-      delete process.env[key];
-    }
-  });
-
-  afterEach(() => {
-    for (const key of envKeys) {
-      if (envBackup[key] === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = envBackup[key];
-      }
-    }
-  });
-
-  test("defaults to public GitHub URLs when no env vars set", () => {
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://api.github.com");
-    expect(config.githubServerUrl).toBe("https://github.com");
-  });
-
-  test("VIBE_GITHUB_* env vars override defaults", () => {
-    process.env.VIBE_GITHUB_API_URL = "https://ghe.corp.com/api/v3";
-    process.env.VIBE_GITHUB_SERVER_URL = "https://ghe.corp.com";
-
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://ghe.corp.com/api/v3");
-    expect(config.githubServerUrl).toBe("https://ghe.corp.com");
-  });
-
-  test("GITHUB_* env vars (CI-provided) override defaults", () => {
-    process.env.GITHUB_API_URL = "https://ghe.corp.com/api/v3";
-    process.env.GITHUB_SERVER_URL = "https://ghe.corp.com";
-
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://ghe.corp.com/api/v3");
-    expect(config.githubServerUrl).toBe("https://ghe.corp.com");
-  });
-
-  test("VIBE_GITHUB_* takes precedence over GITHUB_*", () => {
-    process.env.VIBE_GITHUB_API_URL = "https://vibe-override/api/v3";
-    process.env.GITHUB_API_URL = "https://ci-provided/api/v3";
-
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://vibe-override/api/v3");
-  });
-
-  test("explicit overrides take precedence over all env vars", () => {
-    process.env.VIBE_GITHUB_API_URL = "https://env-value/api/v3";
-
-    const config = loadConfig({
-      githubApiUrl: "https://explicit-override/api/v3",
-    });
-    expect(config.githubApiUrl).toBe("https://explicit-override/api/v3");
-  });
-
-  test("empty string env vars are treated as unset", () => {
-    process.env.VIBE_GITHUB_API_URL = "";
-    process.env.VIBE_GITHUB_SERVER_URL = "";
-
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://api.github.com");
-    expect(config.githubServerUrl).toBe("https://github.com");
-  });
-
-  test("empty VIBE_GITHUB_* falls through to GITHUB_*", () => {
-    process.env.VIBE_GITHUB_API_URL = "";
-    process.env.GITHUB_API_URL = "https://ghe.corp.com/api/v3";
-
-    const config = loadConfig();
-    expect(config.githubApiUrl).toBe("https://ghe.corp.com/api/v3");
-  });
-});

package/src/__tests__/github-adapter.test.ts

@@ -1,57 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { GitHubAdapter, type GitHubConfig } from "../git-platform/github.js";
-
-function createAdapter(overrides: Partial<GitHubConfig> = {}): GitHubAdapter {
-  return new GitHubAdapter({
-    registryRepo: "my-org/vibe-registry",
-    token: "ghp_test123",
-    apiUrl: "https://api.github.com",
-    serverUrl: "https://github.com",
-    ...overrides,
-  });
-}
-
-describe("GitHubAdapter — public GitHub", () => {
-  const adapter = createAdapter();
-
-  test("cloneUrl uses github.com", () => {
-    // Access private method via prototype for testing
-    const url = (adapter as any).cloneUrl();
-    expect(url).toBe(
-      "https://x-access-token:ghp_test123@github.com/my-org/vibe-registry.git",
-    );
-  });
-
-  test("hostname is derived from serverUrl", () => {
-    expect((adapter as any).hostname).toBe("github.com");
-  });
-});
-
-describe("GitHubAdapter — GitHub Enterprise Server", () => {
-  const adapter = createAdapter({
-    apiUrl: "https://ghe.corp.com/api/v3",
-    serverUrl: "https://ghe.corp.com",
-  });
-
-  test("cloneUrl uses GHE hostname", () => {
-    const url = (adapter as any).cloneUrl();
-    expect(url).toBe(
-      "https://x-access-token:ghp_test123@ghe.corp.com/my-org/vibe-registry.git",
-    );
-  });
-
-  test("hostname is derived from GHE serverUrl", () => {
-    expect((adapter as any).hostname).toBe("ghe.corp.com");
-  });
-});
-
-describe("GitHubAdapter — GHE with custom port", () => {
-  const adapter = createAdapter({
-    apiUrl: "https://ghe.corp.com:8443/api/v3",
-    serverUrl: "https://ghe.corp.com:8443",
-  });
-
-  test("hostname does not include port", () => {
-    expect((adapter as any).hostname).toBe("ghe.corp.com");
-  });
-});

package/src/config.ts

@@ -1,72 +0,0 @@
-export type Environment = "dev" | "staging" | "prod";
-export type StorageProviderType = "azure-blob" | "s3" | "gcs";
-export type GitPlatformType = "github" | "azure-devops" | "gitlab";
-
-export interface PublishConfig {
-  environment: Environment;
-  directPush: boolean;
-
-  // Storage
-  storageProvider: StorageProviderType;
-  azureAccountName?: string;
-  azureAccountKey?: string;
-  azureContainerName?: string;
-
-  // Git platform
-  gitPlatform: GitPlatformType;
-  registryRepo?: string;
-  registryToken?: string;
-
-  // GitHub host URLs (for GitHub Enterprise Server support)
-  githubApiUrl: string;
-  githubServerUrl: string;
-
-  // Publisher identity
-  publishedBy: string;
-}
-
-export function loadConfig(overrides: Partial<PublishConfig> = {}): PublishConfig {
-  const env = (overrides.environment ??
-    process.env.VIBE_ENVIRONMENT ??
-    "dev") as Environment;
-
-  return {
-    environment: env,
-    directPush:
-      overrides.directPush ?? process.env.VIBE_DIRECT_PUSH === "true",
-
-    storageProvider: (overrides.storageProvider ??
-      process.env.VIBE_STORAGE_PROVIDER ??
-      "azure-blob") as StorageProviderType,
-    azureAccountName:
-      overrides.azureAccountName ?? process.env.VIBE_STORAGE_ACCOUNT_NAME,
-    azureAccountKey:
-      overrides.azureAccountKey ?? process.env.VIBE_STORAGE_ACCOUNT_KEY,
-    azureContainerName:
-      overrides.azureContainerName ?? process.env.VIBE_STORAGE_CONTAINER_NAME,
-
-    gitPlatform: (overrides.gitPlatform ??
-      process.env.VIBE_GIT_PLATFORM ??
-      "github") as GitPlatformType,
-    registryRepo: overrides.registryRepo ?? process.env.VIBE_REGISTRY_REPO,
-    registryToken: overrides.registryToken ?? process.env.VIBE_REGISTRY_TOKEN,
-
-    githubApiUrl:
-      overrides.githubApiUrl ??
-      (process.env.VIBE_GITHUB_API_URL || undefined) ??
-      (process.env.GITHUB_API_URL || undefined) ??
-      "https://api.github.com",
-
-    githubServerUrl:
-      overrides.githubServerUrl ??
-      (process.env.VIBE_GITHUB_SERVER_URL || undefined) ??
-      (process.env.GITHUB_SERVER_URL || undefined) ??
-      "https://github.com",
-
-    publishedBy:
-      overrides.publishedBy ??
-      process.env.GITHUB_ACTOR ??
-      process.env.USER ??
-      "unknown",
-  };
-}

package/src/git-platform/azure-devops.ts

@@ -1,39 +0,0 @@
-import type { GitPlatformAdapter } from "./interface.js";
-
-/**
- * Azure DevOps Git adapter — stub.
- *
- * To implement: use the Azure DevOps REST API or `az repos` CLI
- * for clone, push, and PR creation.
- */
-export class AzureDevOpsAdapter implements GitPlatformAdapter {
-  constructor(_config: { organization: string; project: string; repo: string; token: string }) {
-    throw new Error(
-      "AzureDevOpsAdapter is not yet implemented. See azure-devops.ts for notes.",
-    );
-  }
-
-  cloneRegistry(_targetDir: string): Promise<string> {
-    throw new Error("Not implemented");
-  }
-
-  createPullRequest(_opts: {
-    repoDir: string;
-    branchName: string;
-    title: string;
-    body: string;
-    baseBranch: string;
-    filesToAdd: string[];
-  }): Promise<{ url: string; number: number }> {
-    throw new Error("Not implemented");
-  }
-
-  pushDirectly(_opts: {
-    repoDir: string;
-    branchName: string;
-    commitMessage: string;
-    filesToAdd: string[];
-  }): Promise<void> {
-    throw new Error("Not implemented");
-  }
-}