sdx-cli 0.2.1

package/dist/commands/service/propose.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@oclif/core");
+const contracts_1 = require("../../lib/contracts");
+const fs_1 = require("../../lib/fs");
+const project_1 = require("../../lib/project");
+const repoRegistry_1 = require("../../lib/repoRegistry");
+const scope_1 = require("../../lib/scope");
+const serviceProposal_1 = require("../../lib/serviceProposal");
+class ServiceProposeCommand extends core_1.Command {
+    static description = 'Draft a new service proposal based on map context and a brief file';
+    static flags = {
+        map: core_1.Flags.string({ required: true, description: 'Map identifier' }),
+        brief: core_1.Flags.string({ required: true, description: 'Path to service brief file' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceProposeCommand);
+        const context = (0, project_1.loadProject)(process.cwd());
+        const scope = (0, scope_1.loadScopeManifest)(flags.map, context.cwd);
+        const repoMap = new Map((0, repoRegistry_1.listAllRepos)(context.db).map((repo) => [repo.name, repo]));
+        const contracts = (0, contracts_1.extractContracts)(flags.map, scope, repoMap);
+        const proposal = (0, serviceProposal_1.proposeService)(flags.map, flags.brief, scope, contracts);
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const outJsonPath = node_path_1.default.join(context.cwd, 'plans', `${stamp}-${flags.map}-service-proposal.json`);
+        const outMdPath = node_path_1.default.join(context.cwd, 'plans', `${stamp}-${flags.map}-service-proposal.md`);
+        (0, fs_1.writeJsonFile)(outJsonPath, proposal);
+        (0, fs_1.writeTextFile)(outMdPath, (0, serviceProposal_1.renderServiceProposalMarkdown)(proposal));
+        (0, project_1.recordRun)(context.db, 'service_propose', 'ok', flags.map, {
+            proposalPath: outMdPath,
+            serviceName: proposal.proposedServiceName,
+        });
+        context.db.close();
+        this.log(`Service proposal written: ${outMdPath}`);
+    }
+}
+exports.default = ServiceProposeCommand;

package/dist/commands/status.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@oclif/core");
+const project_1 = require("../lib/project");
+const fs_1 = require("../lib/fs");
+class StatusCommand extends core_1.Command {
+    static description = 'Show overall workspace status, map health, and recent outputs';
+    async run() {
+        const context = (0, project_1.loadProject)(process.cwd());
+        const repoCount = context.db.prepare('SELECT COUNT(*) AS count FROM repo_registry').get().count;
+        const runCount = context.db.prepare('SELECT COUNT(*) AS count FROM run_log').get().count;
+        this.log(`Initialized: yes`);
+        this.log(`Repositories tracked: ${repoCount}`);
+        this.log(`Runs logged: ${runCount}`);
+        const mapsDir = node_path_1.default.join(context.cwd, 'maps');
+        const mapIds = node_fs_1.default.existsSync(mapsDir)
+            ? node_fs_1.default
+                .readdirSync(mapsDir, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+            : [];
+        this.log(`Maps: ${mapIds.length}`);
+        for (const mapId of mapIds) {
+            const mapDir = node_path_1.default.join(mapsDir, mapId);
+            const hasScope = (0, fs_1.fileExists)(node_path_1.default.join(mapDir, 'scope.json'));
+            const hasServiceMap = (0, fs_1.fileExists)(node_path_1.default.join(mapDir, 'service-map.json'));
+            this.log(`- ${mapId}: scope=${hasScope ? 'yes' : 'no'}, service-map=${hasServiceMap ? 'yes' : 'no'}`);
+        }
+        context.db.close();
+    }
+}
+exports.default = StatusCommand;

package/dist/commands/version.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const package_json_1 = __importDefault(require("../../package.json"));
+const constants_1 = require("../lib/constants");
+class VersionCommand extends core_1.Command {
+    static description = 'Show CLI and artifact schema versions';
+    async run() {
+        this.log(`sdx-cli: ${package_json_1.default.version}`);
+        this.log(`artifact-schema: ${constants_1.SCHEMA_VERSION}`);
+    }
+}
+exports.default = VersionCommand;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const core_1 = require("@oclif/core");
+async function run() {
+    await (0, core_1.run)();
+}
+if (require.main === module) {
+    run().catch(require('@oclif/core/handle'));
+}

package/dist/lib/artifactMigration.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isManagedArtifactPath = isManagedArtifactPath;
+exports.isManagedArtifactPayload = isManagedArtifactPayload;
+const node_path_1 = __importDefault(require("node:path"));
+const MANAGED_ARTIFACT_PATTERNS = [
+    /^maps\/[^/]+\/(scope|service-map|contracts)\.json$/,
+    /^plans\/reviews\/.*\.json$/,
+    /^plans\/.*-service-proposal\.json$/,
+    /^handoffs\/.*\.json$/,
+    /^codex\/(context-packs|runs)\/.*\.json$/,
+];
+function normalizeRelativePath(cwd, filePath) {
+    return node_path_1.default.relative(cwd, filePath).replaceAll(node_path_1.default.sep, '/');
+}
+function isManagedArtifactPath(cwd, filePath) {
+    const relative = normalizeRelativePath(cwd, filePath);
+    return MANAGED_ARTIFACT_PATTERNS.some((pattern) => pattern.test(relative));
+}
+function isManagedArtifactPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.generatedAt === 'string' || typeof candidate.schemaVersion === 'string';
+}

package/dist/lib/bootstrap.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBootstrapStructure = createBootstrapStructure;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+function createBootstrapStructure(org, repoName, cwd = process.cwd()) {
+    const workflowDir = node_path_1.default.join(cwd, '.github', 'workflows');
+    (0, fs_1.ensureDir)(workflowDir);
+    (0, fs_1.writeTextFile)(node_path_1.default.join(workflowDir, 'sdx-ci.yml'), [
+        'name: sdx-ci',
+        '',
+        'on:',
+        '  push:',
+        '    branches: [main]',
+        '  pull_request:',
+        '',
+        'jobs:',
+        '  build-test:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        '          node-version: 20',
+        '      - run: npm ci',
+        '      - run: npm run typecheck',
+        '      - run: npm run test',
+        '      - run: npm run build',
+        '',
+    ].join('\n'));
+    (0, fs_1.writeTextFile)(node_path_1.default.join(cwd, 'BOOTSTRAP.md'), [
+        '# SDX Bootstrap',
+        '',
+        `- Organization: ${org}`,
+        `- Design Repository: ${repoName}`,
+        '',
+        'This repository is configured as a docs-first system-design intelligence workspace.',
+        '',
+    ].join('\n'));
+}

package/dist/lib/bootstrapConsumer.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConsumerTargetDir = resolveConsumerTargetDir;
+exports.resolvePinnedVersion = resolvePinnedVersion;
+exports.writeInstallManifest = writeInstallManifest;
+exports.writePinnedWrapperScript = writePinnedWrapperScript;
+exports.bootstrapConsumer = bootstrapConsumer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const bootstrap_1 = require("./bootstrap");
+const constants_1 = require("./constants");
+const fs_1 = require("./fs");
+const github_1 = require("./github");
+const mapBuilder_1 = require("./mapBuilder");
+const project_1 = require("./project");
+const repoRegistry_1 = require("./repoRegistry");
+const scope_1 = require("./scope");
+const config_1 = require("./config");
+const version_1 = require("./version");
+const semver = require('semver');
+function resolveConsumerTargetDir(mode, designRepo, targetDir, cwd = process.cwd()) {
+    if (targetDir && targetDir.trim().length > 0) {
+        return node_path_1.default.resolve(cwd, targetDir);
+    }
+    if (mode === 'dedicated') {
+        return node_path_1.default.resolve(cwd, designRepo);
+    }
+    return node_path_1.default.resolve(cwd);
+}
+function resolvePinnedVersion(pin, currentVersion) {
+    const fallback = semver.valid(currentVersion);
+    if (!fallback) {
+        throw new Error(`Invalid package version: ${currentVersion}`);
+    }
+    if (!pin || pin.trim().length === 0) {
+        return fallback;
+    }
+    const normalized = semver.valid(pin);
+    if (!normalized) {
+        throw new Error(`Invalid --pin value '${pin}'. Use a concrete semver version (example: 0.1.0).`);
+    }
+    return normalized;
+}
+function writeInstallManifest(targetDir, org, designRepo, mode, pinnedVersion) {
+    const now = new Date().toISOString();
+    const payload = {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: now,
+        installedWithVersion: pinnedVersion,
+        installedAt: now,
+        mode,
+        org,
+        designRepo,
+        templateSchemaVersion: constants_1.SCHEMA_VERSION,
+    };
+    const outPath = node_path_1.default.join(targetDir, '.sdx', 'install.json');
+    (0, fs_1.writeJsonFile)(outPath, payload);
+    return outPath;
+}
+function writePinnedWrapperScript(targetDir, pinnedVersion) {
+    const scriptPath = node_path_1.default.join(targetDir, 'scripts', 'sdx');
+    const body = [
+        '#!/usr/bin/env bash',
+        'set -euo pipefail',
+        `npx --yes sdx-cli@${pinnedVersion} sdx "$@"`,
+        '',
+    ].join('\n');
+    (0, fs_1.writeTextFile)(scriptPath, body);
+    node_fs_1.default.chmodSync(scriptPath, 0o755);
+    return scriptPath;
+}
+function buildSeededAllServicesMap(org, targetDir) {
+    const context = (0, project_1.loadProject)(targetDir);
+    const repos = (0, repoRegistry_1.listAllRepos)(context.db);
+    (0, project_1.ensureMapDir)('all-services', targetDir);
+    const manifest = (0, scope_1.createScopeManifest)('all-services', org, repos.map((repo) => repo.name), targetDir);
+    const archivedOrFork = repos.filter((repo) => repo.archived || repo.fork).map((repo) => repo.name);
+    manifest.explicitExclude = [...new Set([...manifest.explicitExclude, ...archivedOrFork])].sort((a, b) => a.localeCompare(b));
+    (0, scope_1.saveScopeManifest)(manifest, targetDir);
+    (0, project_1.recordRun)(context.db, 'map_create', 'ok', 'all-services', { org, discovered: repos.length, seeded: true });
+    const repoMap = new Map(repos.map((repo) => [repo.name, repo]));
+    const artifact = (0, mapBuilder_1.buildServiceMapArtifact)('all-services', manifest, repoMap);
+    const mapDir = node_path_1.default.join(targetDir, 'maps', 'all-services');
+    (0, fs_1.writeJsonFile)(node_path_1.default.join(mapDir, 'service-map.json'), artifact);
+    (0, fs_1.writeTextFile)(node_path_1.default.join(mapDir, 'service-map.md'), (0, mapBuilder_1.renderServiceMapMarkdown)(artifact));
+    (0, fs_1.writeTextFile)(node_path_1.default.join(mapDir, 'service-map.mmd'), (0, mapBuilder_1.renderServiceMapMermaid)(artifact));
+    (0, project_1.recordRun)(context.db, 'map_build', 'ok', 'all-services', {
+        seeded: true,
+        repos: artifact.repos.length,
+        nodes: artifact.nodes.length,
+        edges: artifact.edges.length,
+    });
+    context.db.close();
+}
+async function bootstrapConsumer(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const mode = options.mode;
+    const targetDir = resolveConsumerTargetDir(mode, options.designRepo, options.targetDir, cwd);
+    const pinnedVersion = resolvePinnedVersion(options.pin, (0, version_1.getCliPackageVersion)());
+    const warnings = [];
+    const nextSteps = [];
+    const result = {
+        targetDir,
+        pinnedVersion,
+        mode,
+        remoteCreated: false,
+        seededDefaultMap: false,
+        warnings,
+        nextSteps,
+    };
+    if (options.createRemote && mode !== 'dedicated') {
+        throw new Error('--create-remote can only be used with --mode dedicated.');
+    }
+    if (mode === 'dedicated' && options.createRemote) {
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            throw new Error('Missing GitHub token. Set GITHUB_TOKEN to use --create-remote.');
+        }
+        const remote = await (0, github_1.ensureOrgRepo)(options.org, options.designRepo, token);
+        result.remoteCreated = remote.created;
+        result.remoteUrl = remote.htmlUrl;
+    }
+    const initContext = (0, project_1.initProject)(targetDir);
+    (0, bootstrap_1.createBootstrapStructure)(options.org, options.designRepo, targetDir);
+    initContext.config.outputRepo.org = options.org;
+    initContext.config.outputRepo.repo = options.designRepo;
+    initContext.config.github.defaultOrg = options.org;
+    (0, config_1.saveConfig)(initContext.config, targetDir);
+    (0, project_1.recordRun)(initContext.db, 'bootstrap_org', 'ok', undefined, {
+        org: options.org,
+        repo: options.designRepo,
+        source: 'bootstrap_consumer',
+    });
+    initContext.db.close();
+    writeInstallManifest(targetDir, options.org, options.designRepo, mode, pinnedVersion);
+    writePinnedWrapperScript(targetDir, pinnedVersion);
+    if (mode === 'dedicated' && !options.createRemote) {
+        nextSteps.push(`gh repo create ${options.org}/${options.designRepo} --private`);
+        nextSteps.push(`cd ${targetDir}`);
+        nextSteps.push(`git init`);
+        nextSteps.push(`git remote add origin git@github.com:${options.org}/${options.designRepo}.git`);
+    }
+    if (options.seedDefaultMap) {
+        const context = (0, project_1.loadProject)(targetDir);
+        const tokenEnvName = context.config.github.tokenEnv;
+        context.db.close();
+        const token = process.env[tokenEnvName];
+        if (!token) {
+            warnings.push(`Skipping --seed-default-map: missing ${tokenEnvName}.`);
+        }
+        else {
+            const syncContext = (0, project_1.loadProject)(targetDir);
+            const repos = await (0, github_1.fetchOrgRepos)(options.org, token);
+            (0, repoRegistry_1.upsertRepos)(syncContext.db, repos);
+            (0, project_1.recordRun)(syncContext.db, 'repo_sync', 'ok', undefined, {
+                org: options.org,
+                count: repos.length,
+                seeded: true,
+            });
+            syncContext.db.close();
+            if (repos.length === 0) {
+                warnings.push(`Skipping --seed-default-map: no repositories discovered for org '${options.org}'.`);
+            }
+            else {
+                buildSeededAllServicesMap(options.org, targetDir);
+                result.seededDefaultMap = true;
+            }
+        }
+    }
+    const finalize = (0, project_1.loadProject)(targetDir);
+    (0, project_1.recordRun)(finalize.db, 'bootstrap_consumer', 'ok', undefined, {
+        org: options.org,
+        designRepo: options.designRepo,
+        mode,
+        targetDir,
+        pinnedVersion,
+        createRemote: Boolean(options.createRemote),
+        seedDefaultMap: Boolean(options.seedDefaultMap),
+        seededDefaultMap: result.seededDefaultMap,
+        warnings: warnings.length,
+    });
+    finalize.db.close();
+    return result;
+}

package/dist/lib/bootstrapQuick.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBootstrapQuickTarget = parseBootstrapQuickTarget;
+const DEFAULT_DESIGN_REPO_SUFFIX = 'system-designer';
+const ORG_REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+const ORG_PATTERN = /^[a-zA-Z0-9._-]+$/;
+function normalizeTarget(target) {
+    let normalized = target.trim();
+    normalized = normalized.replace(/^https?:\/\/github\.com\//i, '');
+    normalized = normalized.replace(/\.git$/i, '');
+    normalized = normalized.replace(/^\/+|\/+$/g, '');
+    return normalized;
+}
+function defaultDesignRepoForOrg(org) {
+    return `${org}-${DEFAULT_DESIGN_REPO_SUFFIX}`;
+}
+function parseBootstrapQuickTarget(target) {
+    const normalized = normalizeTarget(target);
+    if (ORG_REPO_PATTERN.test(normalized)) {
+        const [org, designRepo] = normalized.split('/');
+        return { org, designRepo };
+    }
+    if (ORG_PATTERN.test(normalized)) {
+        return { org: normalized, designRepo: defaultDesignRepoForOrg(normalized) };
+    }
+    throw new Error("Invalid target. Use <org> or <org>/<design-repo> (example: dana0550/dana0550-system-designer).");
+}

package/dist/lib/codex.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodexTask = runCodexTask;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const constants_1 = require("./constants");
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+function loadServiceMap(mapId, cwd = process.cwd()) {
+    const mapPath = node_path_1.default.join((0, paths_1.getMapDir)(mapId, cwd), 'service-map.json');
+    return (0, fs_1.readJsonFile)(mapPath);
+}
+function createPrompt(taskType, contextPack, inputBody) {
+    const lines = [
+        `Task Type: ${taskType}`,
+        '',
+        'Use the attached architecture context and produce actionable engineering output.',
+        '',
+        'Context (JSON):',
+        JSON.stringify(contextPack, null, 2),
+        '',
+    ];
+    if (inputBody) {
+        lines.push('Additional Input:');
+        lines.push(inputBody);
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function runCodexTask(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const serviceMap = loadServiceMap(input.mapId, cwd);
+    const contextPack = {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId: input.mapId,
+        taskType: input.taskType,
+        constraints: input.constraints ?? [
+            'Respect existing service ownership boundaries.',
+            'Keep contract changes backward compatible by default.',
+            'Return explicit assumptions and risks.',
+        ],
+        affectedRepos: [...serviceMap.repos],
+        graphSlice: {
+            nodes: serviceMap.nodes,
+            edges: serviceMap.edges,
+        },
+        inputFile: input.inputFile,
+    };
+    const codexDir = (0, paths_1.getCodexDir)(cwd);
+    const stamp = timestamp();
+    const contextPackPath = node_path_1.default.join(codexDir, 'context-packs', `${stamp}-${input.taskType}.json`);
+    const promptPath = node_path_1.default.join(codexDir, 'runs', `${stamp}-${input.taskType}.prompt.txt`);
+    const runMarkdownPath = node_path_1.default.join(codexDir, 'runs', `${stamp}-${input.taskType}.md`);
+    const runJsonPath = node_path_1.default.join(codexDir, 'runs', `${stamp}-${input.taskType}.json`);
+    (0, fs_1.writeJsonFile)(contextPackPath, contextPack);
+    const inputBody = input.inputFile ? (0, fs_1.safeReadText)(node_path_1.default.resolve(input.inputFile)) : undefined;
+    const prompt = createPrompt(input.taskType, contextPack, inputBody);
+    (0, fs_1.writeTextFile)(promptPath, prompt);
+    let invocationMode = 'stdin';
+    let result = (0, node_child_process_1.spawnSync)(input.codexCommand, ['exec'], {
+        input: prompt,
+        encoding: 'utf8',
+        cwd,
+        timeout: 1000 * 60 * 10,
+    });
+    const firstCombined = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.toLowerCase();
+    const needsArgFallback = result.status !== 0 &&
+        /usage|missing|required/.test(firstCombined) &&
+        !/error/.test(firstCombined);
+    if (needsArgFallback) {
+        invocationMode = 'argv';
+        result = (0, node_child_process_1.spawnSync)(input.codexCommand, ['exec', prompt], {
+            encoding: 'utf8',
+            cwd,
+            timeout: 1000 * 60 * 10,
+        });
+    }
+    const stdout = result.stdout ?? '';
+    const stderr = result.stderr ?? '';
+    const exitCode = typeof result.status === 'number' ? result.status : 1;
+    (0, fs_1.writeJsonFile)(runJsonPath, {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId: input.mapId,
+        taskType: input.taskType,
+        command: input.codexCommand,
+        args: invocationMode === 'stdin' ? ['exec', '<stdin:prompt>'] : ['exec', '<prompt-arg>'],
+        invocationMode,
+        exitCode,
+        stdout,
+        stderr,
+        contextPackPath,
+        promptPath,
+    });
+    const markdown = [
+        `# Codex Run: ${input.taskType}`,
+        '',
+        `- Generated: ${new Date().toISOString()}`,
+        `- Map: ${input.mapId}`,
+        `- Command: ${input.codexCommand}`,
+        `- Exit Code: ${exitCode}`,
+        `- Invocation Mode: ${invocationMode}`,
+        `- Context Pack: ${contextPackPath}`,
+        `- Prompt File: ${promptPath}`,
+        '',
+        '## Stdout',
+        '',
+        '```txt',
+        stdout,
+        '```',
+        '',
+        '## Stderr',
+        '',
+        '```txt',
+        stderr,
+        '```',
+        '',
+    ].join('\n');
+    (0, fs_1.writeTextFile)(runMarkdownPath, markdown);
+    if (result.error) {
+        throw new Error(`Codex invocation failed: ${result.error.message}`);
+    }
+    return {
+        contextPackPath,
+        promptPath,
+        runMarkdownPath,
+        runJsonPath,
+        exitCode,
+        invocationMode,
+    };
+}

package/dist/lib/config.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultConfig = createDefaultConfig;
+exports.saveConfig = saveConfig;
+exports.loadConfig = loadConfig;
+exports.hasConfig = hasConfig;
+const constants_1 = require("./constants");
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function createDefaultConfig(cwd = process.cwd()) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        createdAt: now,
+        updatedAt: now,
+        outputRepo: {
+            rootDir: (0, paths_1.getProjectRoot)(cwd),
+        },
+        codex: {
+            cmd: process.env.CODEX_CMD ?? 'codex',
+        },
+        github: {
+            tokenEnv: 'GITHUB_TOKEN',
+        },
+    };
+}
+function saveConfig(config, cwd = process.cwd()) {
+    config.updatedAt = new Date().toISOString();
+    (0, fs_1.writeJsonFile)((0, paths_1.getConfigPath)(cwd), config);
+}
+function loadConfig(cwd = process.cwd()) {
+    const configPath = (0, paths_1.getConfigPath)(cwd);
+    if (!(0, fs_1.fileExists)(configPath)) {
+        throw new Error('sdx is not initialized. Run `sdx init` first.');
+    }
+    return (0, fs_1.readJsonFile)(configPath);
+}
+function hasConfig(cwd = process.cwd()) {
+    return (0, fs_1.fileExists)((0, paths_1.getConfigPath)(cwd));
+}

package/dist/lib/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIMER_DIMENSIONS = exports.REQUIRED_NFR_KEYWORDS = exports.SCHEMA_VERSION = exports.DB_FILE = exports.CONFIG_FILE = exports.APP_DIR = void 0;
+exports.APP_DIR = '.sdx';
+exports.CONFIG_FILE = 'config.json';
+exports.DB_FILE = 'state.db';
+exports.SCHEMA_VERSION = '1.0.0';
+exports.REQUIRED_NFR_KEYWORDS = [
+    'latency',
+    'availability',
+    'durability',
+    'slo',
+    'failure',
+];
+exports.PRIMER_DIMENSIONS = [
+    'scalability',
+    'reliability',
+    'consistency_model',
+    'data_design',
+    'api_style',
+    'caching',
+    'async_patterns',
+    'security',
+    'observability',
+    'operational_tradeoffs',
+];