sdx-cli 0.2.1

package/dist/lib/repoRegistry.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertRepos = upsertRepos;
+exports.setLocalRepoPath = setLocalRepoPath;
+exports.getRepoByName = getRepoByName;
+exports.listReposByOrg = listReposByOrg;
+exports.listAllRepos = listAllRepos;
+const node_path_1 = __importDefault(require("node:path"));
+function toRecord(row) {
+    return {
+        name: row.name,
+        fullName: row.full_name,
+        org: row.org,
+        defaultBranch: row.default_branch ?? undefined,
+        archived: Boolean(row.archived),
+        fork: Boolean(row.fork),
+        htmlUrl: row.html_url ?? undefined,
+        localPath: row.local_path ?? undefined,
+        source: row.source,
+        lastSyncedAt: row.last_synced_at ?? undefined,
+    };
+}
+function upsertRepos(db, repos) {
+    const stmt = db.prepare(`
+    INSERT INTO repo_registry (name, full_name, org, default_branch, archived, fork, html_url, local_path, source, last_synced_at)
+    VALUES (@name, @full_name, @org, @default_branch, @archived, @fork, @html_url, @local_path, @source, @last_synced_at)
+    ON CONFLICT(name) DO UPDATE SET
+      full_name=excluded.full_name,
+      org=excluded.org,
+      default_branch=excluded.default_branch,
+      archived=excluded.archived,
+      fork=excluded.fork,
+      html_url=excluded.html_url,
+      local_path=COALESCE(repo_registry.local_path, excluded.local_path),
+      source=CASE
+        WHEN repo_registry.local_path IS NOT NULL AND excluded.source='github' THEN 'hybrid'
+        ELSE excluded.source
+      END,
+      last_synced_at=excluded.last_synced_at
+  `);
+    const insertMany = db.transaction((rows) => {
+        for (const repo of rows) {
+            stmt.run({
+                name: repo.name,
+                full_name: repo.fullName,
+                org: repo.org,
+                default_branch: repo.defaultBranch ?? null,
+                archived: repo.archived ? 1 : 0,
+                fork: repo.fork ? 1 : 0,
+                html_url: repo.htmlUrl ?? null,
+                local_path: repo.localPath ?? null,
+                source: repo.source,
+                last_synced_at: repo.lastSyncedAt ?? null,
+            });
+        }
+    });
+    insertMany(repos);
+}
+function setLocalRepoPath(db, name, localPath, org) {
+    const normalized = node_path_1.default.resolve(localPath);
+    const existing = db
+        .prepare('SELECT * FROM repo_registry WHERE name = ?')
+        .get(name);
+    if (existing) {
+        db.prepare(`UPDATE repo_registry SET local_path = ?, source = CASE WHEN source='github' THEN 'hybrid' ELSE 'local' END WHERE name = ?`).run(normalized, name);
+    }
+    else {
+        db.prepare(`INSERT INTO repo_registry (name, full_name, org, archived, fork, local_path, source)
+       VALUES (?, ?, ?, 0, 0, ?, 'local')`).run(name, org ? `${org}/${name}` : name, org ?? 'local', normalized);
+    }
+    return getRepoByName(db, name);
+}
+function getRepoByName(db, name) {
+    const row = db.prepare('SELECT * FROM repo_registry WHERE name = ?').get(name);
+    if (!row) {
+        throw new Error(`Repository not found: ${name}`);
+    }
+    return toRecord(row);
+}
+function listReposByOrg(db, org) {
+    const rows = db
+        .prepare('SELECT * FROM repo_registry WHERE org = ? ORDER BY name')
+        .all(org);
+    return rows.map(toRecord);
+}
+function listAllRepos(db) {
+    const rows = db.prepare('SELECT * FROM repo_registry ORDER BY org, name').all();
+    return rows.map(toRecord);
+}

package/dist/lib/scope.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeEffectiveScope = computeEffectiveScope;
+exports.loadScopeManifest = loadScopeManifest;
+exports.saveScopeManifest = saveScopeManifest;
+exports.createScopeManifest = createScopeManifest;
+exports.applyScopeChange = applyScopeChange;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function computeEffectiveScope(discovered, explicitInclude, explicitExclude) {
+    const overlap = explicitInclude.filter((repo) => explicitExclude.includes(repo));
+    if (overlap.length > 0) {
+        throw new Error(`Invalid scope overrides. Same repo appears in include and exclude: ${overlap.join(', ')}`);
+    }
+    const combined = new Set(discovered);
+    for (const repo of explicitInclude) {
+        combined.add(repo);
+    }
+    for (const repo of explicitExclude) {
+        combined.delete(repo);
+    }
+    return uniqueSorted(Array.from(combined));
+}
+function loadScopeManifest(mapId, cwd = process.cwd()) {
+    const scopePath = node_path_1.default.join((0, paths_1.getMapDir)(mapId, cwd), 'scope.json');
+    if (!(0, fs_1.fileExists)(scopePath)) {
+        throw new Error(`Scope manifest not found for map '${mapId}'. Run 'sdx map create ${mapId} --org <org>' first.`);
+    }
+    return (0, fs_1.readJsonFile)(scopePath);
+}
+function saveScopeManifest(manifest, cwd = process.cwd()) {
+    const mapDir = (0, paths_1.getMapDir)(manifest.mapId, cwd);
+    const scopePath = node_path_1.default.join(mapDir, 'scope.json');
+    manifest.generatedAt = new Date().toISOString();
+    manifest.discovered = uniqueSorted(manifest.discovered);
+    manifest.explicitInclude = uniqueSorted(manifest.explicitInclude);
+    manifest.explicitExclude = uniqueSorted(manifest.explicitExclude);
+    manifest.effective = computeEffectiveScope(manifest.discovered, manifest.explicitInclude, manifest.explicitExclude);
+    (0, fs_1.writeJsonFile)(scopePath, manifest);
+    const logPath = node_path_1.default.join(mapDir, 'scope-change-log.md');
+    const rows = [
+        '# Scope Change Log',
+        '',
+        '| Time | Action | Repositories | Note |',
+        '|---|---|---|---|',
+        ...manifest.history.map((entry) => {
+            const repos = entry.repos.length > 0 ? entry.repos.join(', ') : '-';
+            const note = entry.note ?? '-';
+            return `| ${entry.at} | ${entry.action} | ${repos} | ${note} |`;
+        }),
+        '',
+    ];
+    (0, fs_1.writeTextFile)(logPath, rows.join('\n'));
+    return scopePath;
+}
+function createScopeManifest(mapId, org, discovered, cwd = process.cwd()) {
+    const defaultExclude = discovered.filter((repo) => repo.endsWith('-fork') || repo.endsWith('-archive'));
+    const manifest = {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId,
+        org,
+        discovered: uniqueSorted(discovered),
+        explicitInclude: [],
+        explicitExclude: uniqueSorted(defaultExclude),
+        effective: [],
+        history: [
+            {
+                at: new Date().toISOString(),
+                action: 'create',
+                repos: uniqueSorted(discovered),
+                note: 'Map created from discovered repositories',
+            },
+        ],
+    };
+    manifest.effective = computeEffectiveScope(manifest.discovered, manifest.explicitInclude, manifest.explicitExclude);
+    return manifest;
+}
+function applyScopeChange(mapId, action, repos, note, cwd = process.cwd()) {
+    const manifest = loadScopeManifest(mapId, cwd);
+    const cleanRepos = uniqueSorted(repos);
+    if (action === 'include') {
+        manifest.explicitInclude = uniqueSorted([...manifest.explicitInclude, ...cleanRepos]);
+        manifest.explicitExclude = manifest.explicitExclude.filter((repo) => !cleanRepos.includes(repo));
+    }
+    if (action === 'exclude') {
+        manifest.explicitExclude = uniqueSorted([...manifest.explicitExclude, ...cleanRepos]);
+        manifest.explicitInclude = manifest.explicitInclude.filter((repo) => !cleanRepos.includes(repo));
+    }
+    if (action === 'remove_override') {
+        manifest.explicitInclude = manifest.explicitInclude.filter((repo) => !cleanRepos.includes(repo));
+        manifest.explicitExclude = manifest.explicitExclude.filter((repo) => !cleanRepos.includes(repo));
+    }
+    manifest.history.push({
+        at: new Date().toISOString(),
+        action,
+        repos: cleanRepos,
+        note,
+    });
+    saveScopeManifest(manifest, cwd);
+    return manifest;
+}

package/dist/lib/serviceNoticePlan.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServiceNoticePlan = parseServiceNoticePlan;
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function splitMarkdownTableRow(value) {
+    return value
+        .trim()
+        .replace(/^\|/, '')
+        .replace(/\|$/, '')
+        .split('|')
+        .map((part) => part.trim());
+}
+function parseSections(markdown) {
+    const sections = {};
+    const lines = markdown.split(/\r?\n/);
+    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 parseTargets(section) {
+    const tableLines = section
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('|'));
+    if (tableLines.length < 2) {
+        throw new Error('Service plan section "Target Repositories" must include a markdown table with header and separator.');
+    }
+    const header = splitMarkdownTableRow(tableLines[0]).map((value) => value.toLowerCase());
+    const required = ['repo', 'owner', 'context'];
+    const missing = required.filter((name) => !header.includes(name));
+    if (missing.length > 0) {
+        throw new Error(`Service plan target table is missing required columns: ${missing.join(', ')}`);
+    }
+    const targets = [];
+    for (const line of tableLines.slice(2)) {
+        const row = splitMarkdownTableRow(line);
+        const object = {};
+        for (let i = 0; i < header.length; i += 1) {
+            object[header[i]] = row[i] ?? '';
+        }
+        if (!object.repo.trim() && !object.owner.trim() && !object.context.trim()) {
+            continue;
+        }
+        targets.push({
+            repo: object.repo.trim(),
+            owner: object.owner.trim(),
+            context: object.context.trim(),
+        });
+    }
+    if (targets.length === 0) {
+        throw new Error('Service plan target table must include at least one target row.');
+    }
+    return targets;
+}
+function parseIdentity(section) {
+    const lines = section
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const map = {};
+    for (const line of lines) {
+        const match = line.match(/^[-*]\s*([a-zA-Z0-9_ -]+):\s*(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const key = match[1].trim().toLowerCase().replace(/\s+/g, '_');
+        map[key] = match[2].trim();
+    }
+    const rawName = map.name ?? map.service_name ?? '';
+    const rawServiceId = map.service_id ?? map.id ?? '';
+    if (!rawName && !rawServiceId) {
+        throw new Error('Service plan "Service Identity" section must include bullet keys for at least "name" or "service_id".');
+    }
+    const name = rawName || rawServiceId;
+    const serviceId = rawServiceId || slugify(rawName);
+    if (!serviceId) {
+        throw new Error('Unable to derive service_id from "Service Identity" section.');
+    }
+    return { serviceId, name };
+}
+function requireSection(sections, key) {
+    const value = sections[key];
+    if (!value || value.trim().length === 0) {
+        throw new Error(`Service plan is missing required section: "## ${key}"`);
+    }
+    return value.trim();
+}
+function parseServiceNoticePlan(markdown) {
+    const sections = parseSections(markdown);
+    const identity = parseIdentity(requireSection(sections, 'Service Identity'));
+    const summary = requireSection(sections, 'Summary');
+    const contractSurface = requireSection(sections, 'Contract Surface');
+    const migrationGuidance = requireSection(sections, 'Compatibility and Migration Guidance');
+    const targetSection = requireSection(sections, 'Target Repositories');
+    const targets = parseTargets(targetSection);
+    const changeDetails = sections['Change Details']?.trim() || 'See service plan for implementation details.';
+    return {
+        serviceId: identity.serviceId,
+        name: identity.name,
+        summary,
+        contractSurface,
+        changeDetails,
+        migrationGuidance,
+        targets,
+    };
+}

package/dist/lib/serviceProposal.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proposeService = proposeService;
+exports.renderServiceProposalMarkdown = renderServiceProposalMarkdown;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+function proposeService(mapId, briefPath, scope, contracts) {
+    const absolute = node_path_1.default.resolve(briefPath);
+    const text = node_fs_1.default.readFileSync(absolute, 'utf8');
+    const firstHeadingMatch = text.match(/^#\s+(.+)$/m);
+    const proposedServiceName = firstHeadingMatch?.[1]?.trim() || node_path_1.default.basename(briefPath, node_path_1.default.extname(briefPath));
+    const lower = text.toLowerCase();
+    const integrationCandidates = scope.effective.filter((repo) => lower.includes(repo.toLowerCase()));
+    const contractHeavyRepos = new Set(contracts.slice(0, 50).map((contract) => contract.repo));
+    const likelyDependencies = integrationCandidates.filter((repo) => contractHeavyRepos.has(repo));
+    return {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        mapId,
+        briefPath: absolute,
+        proposedServiceName,
+        options: [
+            {
+                name: 'Option A: Isolated service with explicit contracts',
+                summary: 'Create a standalone service with versioned API contracts and async event boundaries.',
+                tradeoffs: [
+                    'Higher initial setup cost, cleaner ownership boundaries.',
+                    'Simpler rollback and blast-radius control.',
+                ],
+            },
+            {
+                name: 'Option B: Incremental extension of existing service surface',
+                summary: 'Ship initial capability through an existing service boundary before splitting out.',
+                tradeoffs: [
+                    'Faster initial delivery, but weaker long-term modularity.',
+                    'Requires careful migration and deprecation sequencing.',
+                ],
+            },
+        ],
+        integrationCandidates: likelyDependencies.length > 0 ? likelyDependencies : integrationCandidates,
+        coverageTags: [...constants_1.PRIMER_DIMENSIONS],
+    };
+}
+function renderServiceProposalMarkdown(proposal) {
+    const lines = [
+        `# Service Proposal: ${proposal.proposedServiceName}`,
+        '',
+        `- Generated: ${proposal.generatedAt}`,
+        `- Map: ${proposal.mapId}`,
+        `- Brief: ${proposal.briefPath}`,
+        '',
+        '## Candidate Integration Repositories',
+        '',
+        ...(proposal.integrationCandidates.length > 0
+            ? proposal.integrationCandidates.map((repo) => `- ${repo}`)
+            : ['- none detected from brief text']),
+        '',
+        '## Architecture Options',
+        '',
+    ];
+    for (const option of proposal.options) {
+        lines.push(`### ${option.name}`);
+        lines.push('');
+        lines.push(option.summary);
+        lines.push('');
+        for (const tradeoff of option.tradeoffs) {
+            lines.push(`- ${tradeoff}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Coverage Tags');
+    lines.push('');
+    for (const tag of proposal.coverageTags) {
+        lines.push(`- ${tag}`);
+    }
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/status.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.getStatusSummary = getStatusSummary;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function getStatusSummary(db, cwd = process.cwd()) {
+    const repoCount = db.prepare('SELECT COUNT(*) AS count FROM repo_registry').get().count;
+    const runCount = db.prepare('SELECT COUNT(*) AS count FROM run_log').get().count;
+    const mapRows = db
+        .prepare("SELECT DISTINCT map_id FROM run_log WHERE map_id IS NOT NULL AND map_id != '' ORDER BY map_id")
+        .all();
+    const maps = mapRows.map(({ map_id }) => {
+        const mapDir = (0, paths_1.getMapDir)(map_id, cwd);
+        const scopePath = node_path_1.default.join(mapDir, 'scope.json');
+        const updatedAt = (0, fs_1.fileExists)(scopePath) ? node_fs_1.default.statSync(scopePath).mtime.toISOString() : undefined;
+        return {
+            mapId: map_id,
+            hasScope: (0, fs_1.fileExists)(scopePath),
+            hasServiceMap: (0, fs_1.fileExists)(node_path_1.default.join(mapDir, 'service-map.json')),
+            updatedAt,
+        };
+    });
+    return {
+        initialized: true,
+        repoCount,
+        runCount,
+        maps,
+    };
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/version.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCliPackageVersion = getCliPackageVersion;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getCliPackageVersion() {
+    const packageJsonPath = node_path_1.default.resolve(__dirname, '..', '..', 'package.json');
+    const raw = node_fs_1.default.readFileSync(packageJsonPath, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data.version || typeof data.version !== 'string') {
+        throw new Error(`Unable to resolve CLI version from ${packageJsonPath}`);
+    }
+    return data.version;
+}

package/dist/lib/workflows.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMapArtifacts = buildMapArtifacts;
+exports.extractContractArtifacts = extractContractArtifacts;
+exports.generateDocsArtifacts = generateDocsArtifacts;
+const node_path_1 = __importDefault(require("node:path"));
+const contracts_1 = require("./contracts");
+const docs_1 = require("./docs");
+const fs_1 = require("./fs");
+const mapBuilder_1 = require("./mapBuilder");
+const repoRegistry_1 = require("./repoRegistry");
+const scope_1 = require("./scope");
+function buildMapArtifacts(mapId, db, cwd = process.cwd()) {
+    const scope = (0, scope_1.loadScopeManifest)(mapId, cwd);
+    (0, scope_1.saveScopeManifest)(scope, cwd);
+    const repoMap = new Map((0, repoRegistry_1.listAllRepos)(db).map((repo) => [repo.name, repo]));
+    const artifact = (0, mapBuilder_1.buildServiceMapArtifact)(mapId, scope, repoMap);
+    const mapDir = node_path_1.default.join(cwd, 'maps', mapId);
+    const jsonPath = node_path_1.default.join(mapDir, 'service-map.json');
+    const markdownPath = node_path_1.default.join(mapDir, 'service-map.md');
+    const mermaidPath = node_path_1.default.join(mapDir, 'service-map.mmd');
+    (0, fs_1.writeJsonFile)(jsonPath, artifact);
+    (0, fs_1.writeTextFile)(markdownPath, (0, mapBuilder_1.renderServiceMapMarkdown)(artifact));
+    (0, fs_1.writeTextFile)(mermaidPath, (0, mapBuilder_1.renderServiceMapMermaid)(artifact));
+    return {
+        jsonPath,
+        markdownPath,
+        mermaidPath,
+        mapDir,
+    };
+}
+function extractContractArtifacts(mapId, db, cwd = process.cwd()) {
+    const scope = (0, scope_1.loadScopeManifest)(mapId, cwd);
+    const repoMap = new Map((0, repoRegistry_1.listAllRepos)(db).map((repo) => [repo.name, repo]));
+    const contracts = (0, contracts_1.extractContracts)(mapId, scope, repoMap);
+    const mapDir = node_path_1.default.join(cwd, 'maps', mapId);
+    const jsonPath = node_path_1.default.join(mapDir, 'contracts.json');
+    const markdownPath = node_path_1.default.join(mapDir, 'contracts.md');
+    (0, fs_1.writeJsonFile)(jsonPath, contracts);
+    (0, fs_1.writeTextFile)(markdownPath, (0, contracts_1.renderContractsMarkdown)(contracts, mapId));
+    return {
+        jsonPath,
+        markdownPath,
+        count: contracts.length,
+    };
+}
+function generateDocsArtifacts(mapId, db, cwd = process.cwd()) {
+    const scope = (0, scope_1.loadScopeManifest)(mapId, cwd);
+    const repoMap = new Map((0, repoRegistry_1.listAllRepos)(db).map((repo) => [repo.name, repo]));
+    const serviceMap = (0, mapBuilder_1.buildServiceMapArtifact)(mapId, scope, repoMap);
+    const contracts = (0, contracts_1.extractContracts)(mapId, scope, repoMap);
+    const architectureContent = (0, docs_1.renderArchitectureDoc)(mapId, scope, serviceMap, contracts);
+    const architecturePath = node_path_1.default.join(cwd, 'docs', 'architecture', `${mapId}.md`);
+    (0, fs_1.writeTextFile)(architecturePath, architectureContent);
+    const dependencyPath = node_path_1.default.join(cwd, 'catalog', 'dependencies', `${mapId}.md`);
+    const relationLines = [
+        `# Dependency Summary: ${mapId}`,
+        '',
+        ...serviceMap.edges.map((edge) => `- ${edge.from} ${edge.relation} ${edge.to}`),
+        '',
+    ];
+    (0, fs_1.writeTextFile)(dependencyPath, relationLines.join('\n'));
+    return {
+        architecturePath,
+        dependencyPath,
+    };
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "sdx-cli",
+  "version": "0.2.1",
+  "description": "System Design Intelligence CLI",
+  "type": "commonjs",
+  "bin": {
+    "sdx": "./bin/run.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "dev": "tsx src/index.ts",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "changeset publish",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "oclif": {
+    "bin": "sdx",
+    "dirname": "sdx",
+    "commands": "./dist/commands",
+    "topicSeparator": " "
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@oclif/core": "^4.10.3",
+    "@octokit/rest": "^22.0.1",
+    "better-sqlite3": "^12.8.0",
+    "globby": "^16.2.0",
+    "semver": "^7.7.4",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.7",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}