sdx-cli 0.2.1

package/dist/lib/contractChanges.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasContractChangeIndexShape = hasContractChangeIndexShape;
+exports.resolveContractDocRepoPath = resolveContractDocRepoPath;
+exports.resolveContractDocAbsolutePath = resolveContractDocAbsolutePath;
+exports.readContractChangeIndex = readContractChangeIndex;
+exports.parseContractChangeIndexText = parseContractChangeIndexText;
+exports.nextContractChangeId = nextContractChangeId;
+exports.renderContractChangeIndex = renderContractChangeIndex;
+exports.writeContractChangeIndex = writeContractChangeIndex;
+exports.readContractChangeDoc = readContractChangeDoc;
+exports.renderContractChangeDoc = renderContractChangeDoc;
+exports.isNotifiableContractStatus = isNotifiableContractStatus;
+exports.hasRequiredTargetContext = hasRequiredTargetContext;
+exports.computeContractChangeStatus = computeContractChangeStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const CONTRACT_TABLE_HEADER = '| ID | Name | Status | Change Type | Owner | Path | Aliases |';
+const CONTRACT_TABLE_RULE = '|----|------|--------|-------------|-------|------|---------|';
+const TARGET_TABLE_HEADER = '| repo | owner | context | pr_url | state |';
+const TARGET_TABLE_RULE = '|------|-------|---------|--------|-------|';
+function today() {
+    return new Date().toISOString().slice(0, 10);
+}
+function normalizeCell(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function splitMarkdownTableRow(value) {
+    return value
+        .trim()
+        .replace(/^\|/, '')
+        .replace(/\|$/, '')
+        .split('|')
+        .map((part) => normalizeCell(part));
+}
+function escapeCell(value) {
+    return value.replaceAll('|', '\\|');
+}
+function normalizeStatus(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'draft' || normalized === 'approved' || normalized === 'published' || normalized === 'closed') {
+        return normalized;
+    }
+    return 'draft';
+}
+function normalizeTargetState(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'pending' || normalized === 'opened' || normalized === 'merged' || normalized === 'blocked') {
+        return normalized;
+    }
+    return 'pending';
+}
+function parseFrontmatter(text) {
+    if (!text.startsWith('---\n')) {
+        return { frontmatter: {}, body: text };
+    }
+    const end = text.indexOf('\n---\n', 4);
+    if (end === -1) {
+        return { frontmatter: {}, body: text };
+    }
+    const block = text.slice(4, end);
+    const body = text.slice(end + 5);
+    const frontmatter = {};
+    for (const line of block.split(/\r?\n/)) {
+        const idx = line.indexOf(':');
+        if (idx === -1) {
+            continue;
+        }
+        const key = line.slice(0, idx).trim();
+        const value = normalizeCell(line.slice(idx + 1).trim());
+        if (key) {
+            frontmatter[key] = value;
+        }
+    }
+    return { frontmatter, body };
+}
+function hasContractChangeIndexShape(text) {
+    return (text.includes('doc_type: contract_change_index') &&
+        text.includes(CONTRACT_TABLE_HEADER) &&
+        text.includes(CONTRACT_TABLE_RULE));
+}
+function parseSections(text) {
+    const lines = text.split(/\r?\n/);
+    const sections = {};
+    let current = '';
+    let buffer = [];
+    const flush = () => {
+        if (!current) {
+            return;
+        }
+        sections[current] = buffer.join('\n').trim();
+        buffer = [];
+    };
+    for (const line of lines) {
+        const heading = line.match(/^##\s+(.+)$/);
+        if (heading) {
+            flush();
+            current = heading[1].trim();
+            continue;
+        }
+        if (current) {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function parseTargetsFromSection(sectionBody) {
+    const tableLines = sectionBody
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('|'));
+    if (tableLines.length < 2) {
+        return [];
+    }
+    const header = splitMarkdownTableRow(tableLines[0]).map((cell) => cell.toLowerCase());
+    const required = ['repo', 'owner', 'context', 'pr_url', 'state'];
+    if (required.some((col) => !header.includes(col))) {
+        return [];
+    }
+    const targets = [];
+    for (const line of tableLines.slice(2)) {
+        const cells = splitMarkdownTableRow(line);
+        const row = {};
+        for (let i = 0; i < header.length; i += 1) {
+            row[header[i]] = (cells[i] ?? '').trim();
+        }
+        const target = {
+            repo: row.repo ?? '',
+            owner: row.owner ?? '',
+            context: row.context ?? '',
+            prUrl: row.pr_url ?? '',
+            state: normalizeTargetState(row.state ?? ''),
+        };
+        const hasData = Object.values(target).some((value) => value.trim().length > 0);
+        if (hasData) {
+            targets.push(target);
+        }
+    }
+    return targets;
+}
+function renderTargetTable(targets) {
+    const lines = [TARGET_TABLE_HEADER, TARGET_TABLE_RULE];
+    for (const target of targets) {
+        lines.push(`| ${escapeCell(target.repo)} | ${escapeCell(target.owner)} | ${escapeCell(target.context)} | ${escapeCell(target.prUrl)} | ${escapeCell(target.state)} |`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function toPosix(value) {
+    return value.replaceAll('\\\\', '/').replaceAll('\\', '/');
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function buildContractDocCandidates(contractChangeId, rowPath) {
+    const normalizedPath = toPosix(rowPath.trim());
+    const basename = node_path_1.default.posix.basename(normalizedPath || `${contractChangeId}.md`);
+    return unique([
+        normalizedPath,
+        normalizedPath.startsWith('docs/') ? normalizedPath : `docs/${normalizedPath}`,
+        `docs/contracts/${basename}`,
+        `docs/contracts/${contractChangeId}.md`,
+    ]);
+}
+function resolveContractDocRepoPath(contractChangeId, rowPath) {
+    const candidates = buildContractDocCandidates(contractChangeId, rowPath);
+    for (const candidate of candidates) {
+        if (candidate && !candidate.startsWith('/') && candidate.startsWith('docs/')) {
+            return candidate;
+        }
+    }
+    for (const candidate of candidates) {
+        if (candidate && !candidate.startsWith('/')) {
+            return candidate;
+        }
+    }
+    return `docs/contracts/${contractChangeId}.md`;
+}
+function resolveContractDocAbsolutePath(sourceRepoPath, contractChangeId, rowPath) {
+    const candidates = buildContractDocCandidates(contractChangeId, rowPath);
+    for (const repoPath of candidates) {
+        const absolutePath = node_path_1.default.join(sourceRepoPath, repoPath);
+        if (node_fs_1.default.existsSync(absolutePath)) {
+            return absolutePath;
+        }
+    }
+    return node_path_1.default.join(sourceRepoPath, resolveContractDocRepoPath(contractChangeId, rowPath));
+}
+function readContractChangeIndex(indexPath) {
+    if (!node_fs_1.default.existsSync(indexPath)) {
+        return { meta: {}, rows: [] };
+    }
+    const text = node_fs_1.default.readFileSync(indexPath, 'utf8');
+    return parseContractChangeIndexText(text);
+}
+function parseContractChangeIndexText(text) {
+    const { frontmatter, body } = parseFrontmatter(text);
+    const rows = [];
+    for (const line of body.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|')) {
+            continue;
+        }
+        if (trimmed === CONTRACT_TABLE_HEADER || trimmed === CONTRACT_TABLE_RULE) {
+            continue;
+        }
+        const parts = splitMarkdownTableRow(trimmed);
+        if (parts.length < 7 || !parts[0].startsWith('CC-')) {
+            continue;
+        }
+        rows.push({
+            contractChangeId: parts[0],
+            name: parts[1],
+            status: normalizeStatus(parts[2]),
+            changeType: parts[3],
+            owner: parts[4],
+            path: parts[5],
+            aliases: parts[6],
+        });
+    }
+    return {
+        meta: {
+            docType: frontmatter.doc_type,
+            version: frontmatter.version,
+        },
+        rows,
+    };
+}
+function nextContractChangeId(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const match = row.contractChangeId.match(/^CC-(\d{3})$/);
+        if (!match) {
+            continue;
+        }
+        const value = Number(match[1]);
+        if (value > max) {
+            max = value;
+        }
+    }
+    const next = max + 1;
+    return `CC-${String(next).padStart(3, '0')}`;
+}
+function renderContractChangeIndex(rows, meta) {
+    const sorted = [...rows].sort((a, b) => a.contractChangeId.localeCompare(b.contractChangeId));
+    const lines = [
+        '---',
+        `doc_type: ${meta.docType ?? 'contract_change_index'}`,
+        `version: ${meta.version ?? '2.4.0'}`,
+        `last_synced: ${today()}`,
+        '---',
+        '# Contract Changes Index',
+        '',
+        CONTRACT_TABLE_HEADER,
+        CONTRACT_TABLE_RULE,
+    ];
+    for (const row of sorted) {
+        lines.push(`| ${escapeCell(row.contractChangeId)} | ${escapeCell(row.name)} | ${escapeCell(row.status)} | ${escapeCell(row.changeType)} | ${escapeCell(row.owner)} | ${escapeCell(row.path)} | ${escapeCell(row.aliases)} |`);
+    }
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+function writeContractChangeIndex(indexPath, rows, meta) {
+    node_fs_1.default.writeFileSync(indexPath, renderContractChangeIndex(rows, meta), 'utf8');
+}
+function readContractChangeDoc(sourceRepoPath, row) {
+    const absolutePath = resolveContractDocAbsolutePath(sourceRepoPath, row.contractChangeId, row.path);
+    const text = node_fs_1.default.readFileSync(absolutePath, 'utf8');
+    const { frontmatter, body } = parseFrontmatter(text);
+    const sections = parseSections(body);
+    const targets = parseTargetsFromSection(sections['Downstream Notification Context'] ?? '');
+    const relativeFromRoot = toPosix(node_path_1.default.relative(sourceRepoPath, absolutePath));
+    return {
+        contractChangeId: frontmatter.contract_change_id ?? row.contractChangeId,
+        name: frontmatter.name ?? row.name,
+        status: normalizeStatus(frontmatter.status ?? row.status),
+        changeType: frontmatter.change_type ?? row.changeType,
+        owner: frontmatter.owner ?? row.owner,
+        lastUpdated: frontmatter.last_updated ?? today(),
+        absolutePath,
+        relativePath: relativeFromRoot || resolveContractDocRepoPath(row.contractChangeId, row.path),
+        sections: {
+            summary: sections.Summary ?? '',
+            contractSurface: sections['Contract Surface'] ?? '',
+            changeDetails: sections['Change Details'] ?? '',
+            compatibilityAndMigrationGuidance: sections['Compatibility and Migration Guidance'] ?? '',
+        },
+        targets,
+    };
+}
+function renderContractChangeDoc(doc) {
+    const blocks = [
+        '---',
+        'doc_type: contract_change',
+        `contract_change_id: ${doc.contractChangeId}`,
+        `name: ${doc.name}`,
+        `status: ${doc.status}`,
+        `change_type: ${doc.changeType}`,
+        `owner: ${doc.owner}`,
+        `last_updated: ${doc.lastUpdated || today()}`,
+        '---',
+        `# ${doc.name}`,
+        '',
+        '## Summary',
+        doc.sections.summary.trim(),
+        '',
+        '## Contract Surface',
+        doc.sections.contractSurface.trim(),
+        '',
+        '## Change Details',
+        doc.sections.changeDetails.trim(),
+        '',
+        '## Compatibility and Migration Guidance',
+        doc.sections.compatibilityAndMigrationGuidance.trim(),
+        '',
+        '## Downstream Notification Context',
+        renderTargetTable(doc.targets).trimEnd(),
+        '',
+    ];
+    return `${blocks.join('\n')}\n`;
+}
+function isNotifiableContractStatus(status) {
+    return status === 'approved' || status === 'published';
+}
+function hasRequiredTargetContext(target) {
+    return target.repo.trim().length > 0 && target.owner.trim().length > 0 && target.context.trim().length > 0;
+}
+function computeContractChangeStatus(current, targets) {
+    if (targets.length === 0) {
+        return current;
+    }
+    if (targets.every((target) => target.state === 'merged')) {
+        return 'closed';
+    }
+    if (targets.every((target) => target.state === 'opened' || target.state === 'merged')) {
+        return 'published';
+    }
+    return current;
+}

package/dist/lib/contracts.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractContracts = extractContracts;
+exports.renderContractsMarkdown = renderContractsMarkdown;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const constants_1 = require("./constants");
+const fileScan_1 = require("./fileScan");
+const PATTERNS = [
+    { type: 'openapi', regex: /openapi.*\.(ya?ml|json)$/i },
+    { type: 'openapi', regex: /swagger\.(ya?ml|json)$/i },
+    { type: 'graphql', regex: /\.(graphql|gql)$/i },
+    { type: 'proto', regex: /\.proto$/i },
+    { type: 'asyncapi', regex: /asyncapi.*\.(ya?ml|json)$/i },
+];
+function detectType(filePath) {
+    for (const pattern of PATTERNS) {
+        if (pattern.regex.test(filePath)) {
+            return pattern.type;
+        }
+    }
+    return null;
+}
+function tryExtractVersion(filePath) {
+    const lower = filePath.toLowerCase();
+    if (!(lower.endsWith('.json') || lower.endsWith('.yaml') || lower.endsWith('.yml'))) {
+        return undefined;
+    }
+    try {
+        const text = node_fs_1.default.readFileSync(filePath, 'utf8');
+        const data = lower.endsWith('.json') ? JSON.parse(text) : yaml_1.default.parse(text);
+        if (typeof data?.info?.version === 'string') {
+            return data.info.version;
+        }
+        if (typeof data?.version === 'string') {
+            return data.version;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function extractContracts(mapId, scope, reposByName) {
+    const out = [];
+    for (const repoName of scope.effective) {
+        const repo = reposByName.get(repoName);
+        if (!repo?.localPath || !node_fs_1.default.existsSync(repo.localPath)) {
+            continue;
+        }
+        const files = (0, fileScan_1.listFilesRecursive)(repo.localPath);
+        for (const filePath of files) {
+            const type = detectType(filePath);
+            if (!type) {
+                continue;
+            }
+            const relPath = node_path_1.default.relative(repo.localPath, filePath);
+            out.push({
+                schemaVersion: constants_1.SCHEMA_VERSION,
+                generatedAt: new Date().toISOString(),
+                mapId,
+                repo: repoName,
+                type,
+                path: relPath,
+                version: tryExtractVersion(filePath),
+                producers: [repoName],
+                consumers: [],
+                compatibilityStatus: 'unknown',
+                sourcePointer: `${repo.fullName}:${relPath}`,
+            });
+        }
+    }
+    out.sort((a, b) => `${a.repo}:${a.path}`.localeCompare(`${b.repo}:${b.path}`));
+    return out;
+}
+function renderContractsMarkdown(records, mapId) {
+    const lines = [
+        `# Contracts: ${mapId}`,
+        '',
+        `- Generated: ${new Date().toISOString()}`,
+        `- Total contracts: ${records.length}`,
+        '',
+        '| Repo | Type | Path | Version | Compatibility |',
+        '|---|---|---|---|---|',
+        ...records.map((record) => `| ${record.repo} | ${record.type} | ${record.path} | ${record.version ?? '-'} | ${record.compatibilityStatus} |`),
+        '',
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/db.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDb = openDb;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function openDb(cwd = process.cwd()) {
+    (0, fs_1.ensureDir)((0, paths_1.getAppDir)(cwd));
+    const db = new better_sqlite3_1.default((0, paths_1.getDbPath)(cwd));
+    db.pragma('journal_mode = WAL');
+    migrate(db);
+    return db;
+}
+function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS repo_registry (
+      name TEXT PRIMARY KEY,
+      full_name TEXT NOT NULL,
+      org TEXT NOT NULL,
+      default_branch TEXT,
+      archived INTEGER NOT NULL DEFAULT 0,
+      fork INTEGER NOT NULL DEFAULT 0,
+      html_url TEXT,
+      local_path TEXT,
+      source TEXT NOT NULL,
+      last_synced_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS run_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_type TEXT NOT NULL,
+      map_id TEXT,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      metadata_json TEXT
+    );
+  `);
+}

package/dist/lib/docs.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderArchitectureDoc = renderArchitectureDoc;
+function renderArchitectureDoc(mapId, scope, serviceMap, contracts) {
+    const missingLocal = serviceMap.nodes
+        .filter((node) => node.type === 'repo')
+        .filter((node) => !node.metadata?.['localPath'])
+        .map((node) => node.label);
+    const lines = [
+        `# Architecture Overview: ${mapId}`,
+        '',
+        `- Generated: ${new Date().toISOString()}`,
+        `- Org: ${scope.org}`,
+        `- Effective repositories: ${scope.effective.length}`,
+        `- Contracts discovered: ${contracts.length}`,
+        `- Services mapped: ${serviceMap.nodes.filter((node) => node.type === 'service').length}`,
+        '',
+        '## System Design Coverage',
+        '',
+        ...serviceMap.coverageTags.map((tag) => `- ${tag}`),
+        '',
+        '## Repository Scope',
+        '',
+        ...scope.effective.map((repo) => `- ${repo}`),
+        '',
+        '## Integration Signals',
+        '',
+        ...serviceMap.edges.slice(0, 50).map((edge) => `- ${edge.from} ${edge.relation} ${edge.to}`),
+        '',
+        '## Contract Surface',
+        '',
+        ...contracts.slice(0, 100).map((contract) => `- ${contract.repo}: ${contract.type} ${contract.path}`),
+        '',
+    ];
+    if (missingLocal.length > 0) {
+        lines.push('## Partial Visibility');
+        lines.push('');
+        lines.push('The following repositories are in scope but do not have registered local paths:');
+        lines.push('');
+        for (const repo of missingLocal) {
+            lines.push(`- ${repo}`);
+        }
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/fileScan.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFilesRecursive = listFilesRecursive;
+exports.filterByPatterns = filterByPatterns;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', '.next', '.turbo']);
+function listFilesRecursive(rootDir) {
+    const files = [];
+    function walk(current) {
+        const entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (DEFAULT_IGNORE.has(entry.name)) {
+                    continue;
+                }
+                walk(node_path_1.default.join(current, entry.name));
+                continue;
+            }
+            files.push(node_path_1.default.join(current, entry.name));
+        }
+    }
+    if (!node_fs_1.default.existsSync(rootDir)) {
+        return files;
+    }
+    walk(rootDir);
+    return files;
+}
+function filterByPatterns(paths, patterns) {
+    return paths.filter((candidate) => patterns.some((pattern) => pattern.test(candidate)));
+}

package/dist/lib/fs.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.writeTextFile = writeTextFile;
+exports.fileExists = fileExists;
+exports.safeReadText = safeReadText;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function ensureDir(dirPath) {
+    node_fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs_1.default.readFileSync(filePath, 'utf8'));
+}
+function writeJsonFile(filePath, value) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+function writeTextFile(filePath, value) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    node_fs_1.default.writeFileSync(filePath, value, 'utf8');
+}
+function fileExists(filePath) {
+    return node_fs_1.default.existsSync(filePath);
+}
+function safeReadText(filePath) {
+    if (!fileExists(filePath)) {
+        return '';
+    }
+    return node_fs_1.default.readFileSync(filePath, 'utf8');
+}

package/dist/lib/github.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrgRepos = fetchOrgRepos;
+exports.ensureOrgRepo = ensureOrgRepo;
+async function fetchOrgRepos(org, token) {
+    const { Octokit } = await import('@octokit/rest');
+    const octokit = new Octokit({ auth: token });
+    const now = new Date().toISOString();
+    const repos = await octokit.paginate(octokit.rest.repos.listForOrg, {
+        org,
+        per_page: 100,
+        type: 'all',
+    });
+    return repos.map((repo) => ({
+        name: repo.name,
+        fullName: repo.full_name,
+        org,
+        defaultBranch: repo.default_branch,
+        archived: Boolean(repo.archived),
+        fork: Boolean(repo.fork),
+        htmlUrl: repo.html_url,
+        source: 'github',
+        lastSyncedAt: now,
+    }));
+}
+async function ensureOrgRepo(org, repoName, token) {
+    const { Octokit } = await import('@octokit/rest');
+    const octokit = new Octokit({ auth: token });
+    try {
+        const existing = await octokit.rest.repos.get({ owner: org, repo: repoName });
+        return {
+            created: false,
+            htmlUrl: existing.data.html_url ?? undefined,
+        };
+    }
+    catch (error) {
+        const status = Number(error.status);
+        if (status !== 404) {
+            throw error;
+        }
+    }
+    const created = await octokit.rest.repos.createInOrg({
+        org,
+        name: repoName,
+        private: true,
+        auto_init: false,
+    });
+    return {
+        created: true,
+        htmlUrl: created.data.html_url ?? undefined,
+    };
+}