@uxmaltech/collab-cli 0.1.0

package/dist/stages/canon-ingest.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonIngestStage = void 0;
+exports.ingestCanonFiles = ingestCanonFiles;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../lib/config");
+const canon_resolver_1 = require("../lib/canon-resolver");
+const mcp_client_1 = require("../lib/mcp-client");
+const service_health_1 = require("../lib/service-health");
+const MAX_DOCS_PER_REQUEST = 100;
+/**
+ * Recursively collects all `.md` files under a directory.
+ */
+function collectMarkdownFiles(dir) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const results = [];
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectMarkdownFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.md')) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+/**
+ * Reads files and produces IngestDocument objects with paths relative to a base.
+ */
+function filesToDocuments(files, baseDir) {
+    return files.map((f) => ({
+        path: node_path_1.default.relative(baseDir, f),
+        content: node_fs_1.default.readFileSync(f, 'utf8'),
+    }));
+}
+function chunkDocuments(documents, batchSize) {
+    const chunks = [];
+    for (let index = 0; index < documents.length; index += batchSize) {
+        chunks.push(documents.slice(index, index + batchSize));
+    }
+    return chunks;
+}
+/**
+ * Normalizes a repo identifier/url into an "owner/repo" slug when possible.
+ */
+function normalizeGitHubRepoSlug(repo) {
+    return repo
+        .trim()
+        .replace(/\/+$/, '')
+        .replace(/\.git$/, '')
+        .replace(/^https?:\/\/github\.com\//i, '')
+        .replace(/^git@github\.com:/i, '')
+        .replace(/^ssh:\/\/git@github\.com\//i, '');
+}
+/**
+ * Derives a scope name from a business canon repo slug.
+ * e.g. "uxmaltech/my-app-architecture.git/" → "my-app-architecture"
+ */
+function businessScopeFromRepo(repo) {
+    const normalized = normalizeGitHubRepoSlug(repo);
+    const scope = normalized.split('/').filter(Boolean).pop();
+    return scope ?? normalized;
+}
+function parseRepoIdentityFromRemote(remoteUrl) {
+    if (!/github\.com[:/]/i.test(remoteUrl)) {
+        return undefined;
+    }
+    const normalized = normalizeGitHubRepoSlug(remoteUrl);
+    const [organization, repoName] = normalized.split('/').filter(Boolean);
+    if (!organization || !repoName) {
+        return undefined;
+    }
+    return {
+        organization,
+        repo: `${organization}/${repoName}`,
+        scope: repoName,
+    };
+}
+function sanitizeScope(value, fallback) {
+    const normalized = value
+        .trim()
+        .replace(/\/+$/, '')
+        .replace(/\.git$/, '');
+    const scope = normalized.split('/').filter(Boolean).pop();
+    return scope && scope.length > 0 ? scope : fallback;
+}
+function resolveRepoIdentity(repoDir, fallbackScope) {
+    try {
+        const remoteUrl = (0, node_child_process_1.execFileSync)('git', ['-C', repoDir, 'remote', 'get-url', 'origin'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        const fromRemote = parseRepoIdentityFromRemote(remoteUrl);
+        if (fromRemote) {
+            return fromRemote;
+        }
+    }
+    catch {
+        // Fallback below when repo has no git origin or git is unavailable.
+    }
+    const scope = sanitizeScope(fallbackScope, 'repo');
+    return {
+        organization: 'local',
+        repo: `local/${scope}`,
+        scope,
+    };
+}
+async function ingestInBatches(baseUrl, payload, apiKey, timeoutMs) {
+    const chunks = chunkDocuments(payload.documents, MAX_DOCS_PER_REQUEST);
+    let totalFiles = 0;
+    let totalPoints = 0;
+    let totalNodes = 0;
+    let totalEdges = 0;
+    let collection = '';
+    let space = '';
+    for (const documents of chunks) {
+        const result = await (0, mcp_client_1.ingestDocuments)(baseUrl, { ...payload, documents }, apiKey, timeoutMs);
+        totalFiles += result.vector.ingested_files;
+        totalPoints += result.vector.total_points;
+        totalNodes += result.graph.nodes_created;
+        totalEdges += result.graph.edges_created;
+        collection = collection || result.vector.collection;
+        space = space || result.graph.space;
+    }
+    return {
+        vector: {
+            ingested_files: totalFiles,
+            total_points: totalPoints,
+            collection: collection || payload.scope,
+        },
+        graph: {
+            nodes_created: totalNodes,
+            edges_created: totalEdges,
+            space: space || payload.scope,
+        },
+    };
+}
+async function ingestCanonFiles(ctx) {
+    const baseUrl = (0, mcp_client_1.getMcpBaseUrl)(ctx.config);
+    const env = (0, service_health_1.loadRuntimeEnv)(ctx.config);
+    const apiKey = (0, mcp_client_1.resolveMcpApiKey)(env);
+    const timeoutMs = (0, mcp_client_1.resolveMcpHttpTimeoutMs)(env);
+    // --- Framework canon (uxmaltech) ---
+    const uxmaltechFiles = collectMarkdownFiles(ctx.config.uxmaltechDir);
+    if (uxmaltechFiles.length > 0) {
+        ctx.logger.info(`Ingesting ${uxmaltechFiles.length} framework architecture file(s) via HTTP.`);
+        const payload = {
+            context: 'technical',
+            scope: 'uxmaltech',
+            organization: 'uxmaltech',
+            repo: 'uxmaltech/collab-architecture',
+            documents: filesToDocuments(uxmaltechFiles, ctx.config.uxmaltechDir),
+        };
+        const result = await ingestInBatches(baseUrl, payload, apiKey, timeoutMs);
+        ctx.logger.info(`Framework canon ingested: ${result.vector.ingested_files} files, ` +
+            `${result.vector.total_points} vectors, ${result.graph.nodes_created} graph nodes.`);
+    }
+    else {
+        ctx.logger.info('No framework architecture files found to ingest.');
+    }
+    // --- Business canon ---
+    if ((0, canon_resolver_1.isBusinessCanonConfigured)(ctx.config)) {
+        const localDir = ctx.config.canons?.business?.localDir ?? 'business';
+        const businessDir = node_path_1.default.join(ctx.config.architectureDir, localDir);
+        const businessFiles = collectMarkdownFiles(businessDir);
+        if (businessFiles.length > 0) {
+            const configuredBusinessRepo = ctx.config.canons.business.repo;
+            const normalizedBusinessRepo = normalizeGitHubRepoSlug(configuredBusinessRepo);
+            const businessScope = businessScopeFromRepo(normalizedBusinessRepo);
+            const businessOrg = normalizedBusinessRepo.split('/')[0] ?? 'uxmaltech';
+            const businessRepo = normalizedBusinessRepo.includes('/')
+                ? normalizedBusinessRepo
+                : `${businessOrg}/${normalizedBusinessRepo}`;
+            ctx.logger.info(`Ingesting ${businessFiles.length} business architecture file(s) via HTTP.`);
+            const payload = {
+                context: 'technical',
+                scope: businessScope,
+                organization: businessOrg,
+                repo: businessRepo,
+                documents: filesToDocuments(businessFiles, businessDir),
+            };
+            const result = await ingestInBatches(baseUrl, payload, apiKey, timeoutMs);
+            ctx.logger.info(`Business canon ingested: ${result.vector.ingested_files} files, ` +
+                `${result.vector.total_points} vectors, ${result.graph.nodes_created} graph nodes.`);
+        }
+        else {
+            ctx.logger.info('No business architecture files found to ingest.');
+        }
+    }
+    // --- Repo architecture docs ---
+    if ((0, config_1.isWorkspaceMode)(ctx.config)) {
+        for (const rc of (0, config_1.resolveRepoConfigs)(ctx.config)) {
+            const repoFiles = collectMarkdownFiles(rc.architectureRepoDir);
+            if (repoFiles.length === 0) {
+                continue;
+            }
+            const repoIdentity = resolveRepoIdentity(rc.repoDir, rc.name);
+            ctx.logger.info(`Ingesting ${repoFiles.length} file(s) from repo ${repoIdentity.repo} via HTTP.`);
+            const payload = {
+                context: 'technical',
+                scope: repoIdentity.scope,
+                organization: repoIdentity.organization,
+                repo: repoIdentity.repo,
+                documents: filesToDocuments(repoFiles, rc.architectureRepoDir),
+            };
+            const result = await ingestInBatches(baseUrl, payload, apiKey, timeoutMs);
+            ctx.logger.info(`Repo ${repoIdentity.repo} ingested: ${result.vector.ingested_files} files, ` +
+                `${result.vector.total_points} vectors.`);
+        }
+        return;
+    }
+    // Non-workspace mode: ingest local repo architecture docs (`docs/architecture/repo`).
+    const repoFiles = collectMarkdownFiles(ctx.config.repoDir);
+    if (repoFiles.length > 0) {
+        const fallbackScope = node_path_1.default.basename(ctx.config.workspaceDir);
+        const repoIdentity = resolveRepoIdentity(ctx.config.workspaceDir, fallbackScope);
+        ctx.logger.info(`Ingesting ${repoFiles.length} file(s) from local repo architecture via HTTP.`);
+        const payload = {
+            context: 'technical',
+            scope: repoIdentity.scope,
+            organization: repoIdentity.organization,
+            repo: repoIdentity.repo,
+            documents: filesToDocuments(repoFiles, ctx.config.repoDir),
+        };
+        const result = await ingestInBatches(baseUrl, payload, apiKey, timeoutMs);
+        ctx.logger.info(`Repo architecture ingested: ${result.vector.ingested_files} files, ` +
+            `${result.vector.total_points} vectors.`);
+    }
+}
+exports.canonIngestStage = {
+    id: 'canon-ingest',
+    title: 'Ingest canonical architecture files into MCP',
+    recovery: [
+        'Ensure MCP service is running and accessible.',
+        'Run collab init --resume to retry canon ingestion.',
+    ],
+    run: async (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would ingest architecture files into MCP via HTTP.');
+            return;
+        }
+        await ingestCanonFiles(ctx);
+    },
+};

package/dist/stages/canon-rebuild-graph.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonRebuildGraphStage = void 0;
+const mcp_client_1 = require("../lib/mcp-client");
+const service_health_1 = require("../lib/service-health");
+const errors_1 = require("../lib/errors");
+exports.canonRebuildGraphStage = {
+    id: 'canon-rebuild-graph',
+    title: 'Rebuild NebulaGraph seeds via MCP',
+    recovery: [
+        'Ensure infrastructure is running: collab infra up',
+        'Ensure MCP server is running: collab mcp start',
+        'Run collab canon rebuild --confirm --graph to retry.',
+    ],
+    run: async (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would re-seed NebulaGraph via MCP HTTP endpoint.');
+            return;
+        }
+        const env = (0, service_health_1.loadRuntimeEnv)(ctx.config);
+        // Pre-check: is MCP reachable?
+        const health = await (0, service_health_1.waitForMcpHealth)(env, service_health_1.REBUILD_HEALTH_OPTIONS);
+        if (!health.ok) {
+            throw new errors_1.CliError('MCP server is not reachable. Start it with: collab mcp start');
+        }
+        const baseUrl = (0, mcp_client_1.getMcpBaseUrl)(ctx.config);
+        const apiKey = (0, mcp_client_1.resolveMcpApiKey)(env);
+        const timeoutMs = (0, mcp_client_1.resolveMcpHttpTimeoutMs)(env);
+        ctx.logger.info('Triggering NebulaGraph re-seed via MCP...');
+        const result = await (0, mcp_client_1.triggerGraphSeed)(baseUrl, apiKey, timeoutMs);
+        ctx.logger.info(`Graph re-seed complete: ${result.nodes_created} nodes, ${result.edges_created} edges.`);
+    },
+};

package/dist/stages/canon-rebuild-indexes.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 });
+exports.canonRebuildIndexesStage = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const canon_index_generator_1 = require("../lib/canon-index-generator");
+const canon_index_targets_1 = require("../lib/canon-index-targets");
+exports.canonRebuildIndexesStage = {
+    id: 'canon-rebuild-indexes',
+    title: 'Regenerate canon index files',
+    recovery: [
+        'Verify write permissions for the architecture directory.',
+        'Run collab canon rebuild --confirm --indexes to retry.',
+    ],
+    run: (ctx) => {
+        const archDir = ctx.config.architectureDir;
+        const targets = (0, canon_index_targets_1.getCanonIndexTargets)(archDir);
+        if (ctx.executor.dryRun) {
+            ctx.logger.info(`[dry-run] Would regenerate ${targets.length} index files under ${archDir}.`);
+            for (const t of targets) {
+                ctx.logger.info(`  ${node_path_1.default.relative(archDir, t.outputFile)}`);
+            }
+            return;
+        }
+        let regenerated = 0;
+        for (const target of targets) {
+            const entries = (0, canon_index_generator_1.scanCanonEntries)(target.scanDir);
+            const content = (0, canon_index_generator_1.generateIndexReadme)(target.sectionTitle, target.description, entries);
+            ctx.executor.ensureDirectory(node_path_1.default.dirname(target.outputFile));
+            ctx.executor.writeFile(target.outputFile, content, {
+                description: `rebuild index ${target.sectionTitle}`,
+            });
+            ctx.logger.info(`Rebuilt ${node_path_1.default.relative(archDir, target.outputFile)} (${entries.length} entries)`);
+            regenerated++;
+        }
+        ctx.logger.info(`Index rebuild complete: ${regenerated} files regenerated.`);
+    },
+};

package/dist/stages/canon-rebuild-snapshot.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonRebuildSnapshotStage = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const canon_index_targets_1 = require("../lib/canon-index-targets");
+/**
+ * Recursively copies files from sourceDir into snapshotDir using the executor.
+ * Reads go through `fs` directly (the Executor API only wraps side-effect
+ * operations: commands, writes, mkdirs), writes go through `ctx.executor`.
+ * Returns the number of files copied.
+ */
+function snapshotDirectory(sourceDir, snapshotDir, ctx) {
+    if (!node_fs_1.default.existsSync(sourceDir))
+        return 0;
+    let count = 0;
+    const entries = node_fs_1.default.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = node_path_1.default.join(sourceDir, entry.name);
+        const dest = node_path_1.default.join(snapshotDir, entry.name);
+        if (entry.isDirectory()) {
+            ctx.executor.ensureDirectory(dest);
+            count += snapshotDirectory(src, dest, ctx);
+        }
+        else if (entry.isFile()) {
+            const content = node_fs_1.default.readFileSync(src, 'utf8');
+            ctx.executor.writeFile(dest, content, { description: `snapshot ${entry.name}` });
+            count++;
+        }
+    }
+    return count;
+}
+exports.canonRebuildSnapshotStage = {
+    id: 'canon-rebuild-snapshot',
+    title: 'Create pre-rebuild snapshot',
+    recovery: [
+        'Check .collab/snapshots/ for existing snapshots.',
+    ],
+    run: (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would create snapshot of current canon artifacts.');
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const snapshotBase = node_path_1.default.join(ctx.config.collabDir, 'snapshots', timestamp);
+        ctx.executor.ensureDirectory(snapshotBase);
+        let totalFiles = 0;
+        // Snapshot index README files (derived from shared canon-index-targets)
+        const indexPaths = (0, canon_index_targets_1.getSnapshotIndexPaths)(ctx.config.architectureDir);
+        for (const relPath of indexPaths) {
+            const src = node_path_1.default.join(ctx.config.architectureDir, relPath);
+            if (node_fs_1.default.existsSync(src)) {
+                const dest = node_path_1.default.join(snapshotBase, 'indexes', relPath);
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(dest));
+                ctx.executor.writeFile(dest, node_fs_1.default.readFileSync(src, 'utf8'), {
+                    description: `snapshot index ${relPath}`,
+                });
+                totalFiles++;
+            }
+        }
+        // Snapshot graph seed files (indexed mode only)
+        if (ctx.config.mode === 'indexed') {
+            const graphSeedDir = node_path_1.default.join(ctx.config.uxmaltechDir, 'graph', 'seed');
+            if (node_fs_1.default.existsSync(graphSeedDir)) {
+                const snapshotGraphDir = node_path_1.default.join(snapshotBase, 'graph-seed');
+                ctx.executor.ensureDirectory(snapshotGraphDir);
+                totalFiles += snapshotDirectory(graphSeedDir, snapshotGraphDir, ctx);
+            }
+        }
+        ctx.logger.info(`Snapshot created: ${snapshotBase} (${totalFiles} file(s))`);
+    },
+};

package/dist/stages/canon-rebuild-validate.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonRebuildValidateStage = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const canon_index_targets_1 = require("../lib/canon-index-targets");
+function validateIndexFiles(ctx) {
+    const errors = [];
+    const archDir = ctx.config.architectureDir;
+    const targets = (0, canon_index_targets_1.getCanonIndexTargets)(archDir);
+    for (const target of targets) {
+        const fullPath = target.outputFile;
+        const relPath = node_path_1.default.relative(archDir, fullPath);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            errors.push(`Missing index file: ${relPath}`);
+            continue;
+        }
+        const content = node_fs_1.default.readFileSync(fullPath, 'utf8');
+        if (content.trim().length === 0) {
+            errors.push(`Empty index file: ${relPath}`);
+        }
+    }
+    return errors;
+}
+exports.canonRebuildValidateStage = {
+    id: 'canon-rebuild-validate',
+    title: 'Validate rebuilt artifacts',
+    recovery: [
+        'Review validation errors above.',
+        'Run collab canon rebuild --confirm to retry the full rebuild.',
+    ],
+    run: (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would validate rebuilt canon artifacts.');
+            return;
+        }
+        const rebuildIndexes = ctx.options?.rebuildIndexes;
+        const errors = [];
+        if (rebuildIndexes) {
+            errors.push(...validateIndexFiles(ctx));
+        }
+        if (errors.length > 0) {
+            ctx.logger.warn(`Validation found ${errors.length} issue(s):`);
+            for (const e of errors) {
+                ctx.logger.warn(`  - ${e}`);
+            }
+            // Warn but do not fail — missing directories may be expected
+            // in workspaces that haven't scaffolded all categories yet.
+        }
+        else {
+            ctx.logger.info('Post-rebuild validation passed.');
+        }
+    },
+};

package/dist/stages/canon-rebuild-vectors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonRebuildVectorsStage = void 0;
+const service_health_1 = require("../lib/service-health");
+const errors_1 = require("../lib/errors");
+const canon_ingest_1 = require("./canon-ingest");
+exports.canonRebuildVectorsStage = {
+    id: 'canon-rebuild-vectors',
+    title: 'Rebuild vector embeddings via MCP',
+    recovery: [
+        'Ensure infrastructure is running: collab infra up',
+        'Ensure MCP server is running: collab mcp start',
+        'Run collab canon rebuild --confirm --vectors to retry.',
+    ],
+    run: async (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would re-ingest all canon files into Qdrant via MCP HTTP.');
+            return;
+        }
+        const env = (0, service_health_1.loadRuntimeEnv)(ctx.config);
+        // Pre-check: is MCP reachable?
+        const health = await (0, service_health_1.waitForMcpHealth)(env, service_health_1.REBUILD_HEALTH_OPTIONS);
+        if (!health.ok) {
+            throw new errors_1.CliError('MCP server is not reachable. Start it with: collab mcp start');
+        }
+        ctx.logger.info('Re-ingesting all canon files into Qdrant vector store...');
+        await (0, canon_ingest_1.ingestCanonFiles)(ctx);
+        ctx.logger.info('Vector embedding rebuild complete.');
+    },
+};

package/dist/stages/canon-scaffold.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonScaffoldStage = void 0;
+const canon_scaffold_1 = require("../lib/canon-scaffold");
+exports.canonScaffoldStage = {
+    id: 'canon-scaffold',
+    title: 'Generate canonical architecture scaffold',
+    recovery: [
+        'Verify write permissions for docs/architecture directory.',
+        'Run collab init --resume to retry scaffold generation.',
+    ],
+    run: (ctx) => {
+        (0, canon_scaffold_1.generateCanonScaffold)(ctx);
+    },
+};

package/dist/stages/canon-sync.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonSyncStage = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const canon_resolver_1 = require("../lib/canon-resolver");
+const github_auth_1 = require("../lib/github-auth");
+exports.canonSyncStage = {
+    id: 'canon-sync',
+    title: 'Sync canonical architecture',
+    recovery: [
+        'Verify internet connectivity for git clone/pull.',
+        'Run collab update-canons manually, then collab init --resume.',
+    ],
+    run: (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would sync canons and copy to uxmaltech/.');
+            return;
+        }
+        // ── Framework canon ──────────────────────────────────────
+        if (!(0, canon_resolver_1.isCanonsAvailable)()) {
+            ctx.logger.info('Canons not installed. Downloading collab-architecture...');
+        }
+        const ok = (0, canon_resolver_1.syncCanons)((msg) => ctx.logger.info(msg));
+        if (!ok || !(0, canon_resolver_1.isCanonsAvailable)()) {
+            throw new Error('Failed to sync collab-architecture canons. Check git access and connectivity.');
+        }
+        const targetDir = ctx.config.uxmaltechDir;
+        ctx.logger.info(`Copying framework canon to ${targetDir}...`);
+        const fileCount = (0, canon_resolver_1.copyCanonContent)(targetDir, (msg) => ctx.logger.debug(msg));
+        ctx.logger.info(`Framework canon sync: ${fileCount} file(s) copied to uxmaltech/.`);
+        // ── Business canon ───────────────────────────────────────
+        if ((0, canon_resolver_1.isBusinessCanonConfigured)(ctx.config)) {
+            const auth = (0, github_auth_1.loadGitHubAuth)(ctx.config.collabDir);
+            const token = auth?.token;
+            const bizOk = (0, canon_resolver_1.syncBusinessCanon)(ctx.config, (msg) => ctx.logger.info(msg), token);
+            if (!bizOk) {
+                throw new Error('Failed to sync business canon. Check repo access and connectivity.');
+            }
+            const localDir = ctx.config.canons?.business?.localDir ?? 'business';
+            const bizTargetDir = node_path_1.default.join(ctx.config.architectureDir, localDir);
+            ctx.logger.info(`Copying business canon to ${bizTargetDir}...`);
+            const bizFileCount = (0, canon_resolver_1.copyBusinessCanonContent)(ctx.config, bizTargetDir, (msg) => ctx.logger.debug(msg));
+            ctx.logger.info(`Business canon sync: ${bizFileCount} file(s) copied to ${localDir}/.`);
+        }
+    },
+};

package/dist/stages/ci-setup.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ciSetupStage = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const orchestrator_1 = require("../lib/orchestrator");
+const ci_1 = require("../templates/ci");
+exports.ciSetupStage = {
+    id: 'ci-setup',
+    title: 'Generate CI workflow files for architecture',
+    recovery: [
+        'Verify write permissions for .github/workflows/ directory.',
+        'Run collab init --resume to retry CI setup.',
+    ],
+    run: (ctx) => {
+        if (ctx.options?.skipCi) {
+            ctx.logger.info('Skipping CI workflow generation by user choice.');
+            return;
+        }
+        const workflowDir = node_path_1.default.join((0, orchestrator_1.getRepoBaseDir)(ctx), '.github', 'workflows');
+        let created = 0;
+        let skipped = 0;
+        // PR workflow — both modes
+        const prFile = node_path_1.default.join(workflowDir, 'architecture-pr.yml');
+        if (!ctx.executor.dryRun && node_fs_1.default.existsSync(prFile)) {
+            ctx.logger.debug('PR workflow already exists, skipping: architecture-pr.yml');
+            skipped++;
+        }
+        else {
+            ctx.executor.ensureDirectory(workflowDir);
+            ctx.executor.writeFile(prFile, ci_1.architecturePrTemplate, {
+                description: 'write architecture PR validation workflow',
+            });
+            created++;
+        }
+        // Merge workflow — indexed mode only
+        if (ctx.config.mode === 'indexed') {
+            const mergeFile = node_path_1.default.join(workflowDir, 'architecture-merge.yml');
+            if (!ctx.executor.dryRun && node_fs_1.default.existsSync(mergeFile)) {
+                ctx.logger.debug('Merge workflow already exists, skipping: architecture-merge.yml');
+                skipped++;
+            }
+            else {
+                ctx.executor.ensureDirectory(workflowDir);
+                ctx.executor.writeFile(mergeFile, ci_1.architectureMergeTemplate, {
+                    description: 'write architecture merge ingestion workflow',
+                });
+                created++;
+            }
+        }
+        ctx.logger.info(`CI workflows: ${created} file(s) created, ${skipped} existing file(s) preserved.`);
+    },
+};