@uxmaltech/collab-cli 0.1.6 → 0.1.7

package/dist/commands/init.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInitCommand = registerInitCommand;
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const command_context_1 = require("../lib/command-context");
 const compose_validator_1 = require("../lib/compose-validator");
@@ -12,6 +13,7 @@ const config_1 = require("../lib/config");
 const ecosystem_1 = require("../lib/ecosystem");
 const compose_renderer_1 = require("../lib/compose-renderer");
 const errors_1 = require("../lib/errors");
+const github_search_1 = require("../lib/github-search");
 const infra_type_1 = require("../lib/infra-type");
 const mode_1 = require("../lib/mode");
 const parsers_1 = require("../lib/parsers");
@@ -187,9 +189,10 @@ function buildGitHubAuthStage(effectiveConfig, logger, options) {
             'Run collab init --resume after fixing GitHub access.',
         ],
         run: async () => {
-            // Skip if no business canon is configured — GitHub auth is only needed for private repos
-            if (!effectiveConfig.canons?.business) {
-                logger.info('No business canon configured; skipping GitHub authorization.');
+            // Skip if no business canon or local source — GitHub auth only needed for remote repos
+            const canon = effectiveConfig.canons?.business;
+            if (!canon || canon.source === 'local') {
+                logger.info('No GitHub canon configured; skipping GitHub authorization.');
                 return;
             }
             // Check for pre-existing valid token
@@ -217,48 +220,146 @@ function buildGitHubAuthStage(effectiveConfig, logger, options) {
         },
     };
 }
+const LOCAL_PATH_RE = /^[/~.]/;
+/**
+ * Expands `~`, resolves to absolute, and validates the path is an existing directory.
+ * Throws CliError on failure.
+ */
+function resolveLocalCanonPath(rawPath) {
+    const resolved = node_path_1.default.resolve(rawPath.replace(/^~/, node_os_1.default.homedir()));
+    if (!node_fs_1.default.existsSync(resolved) || !node_fs_1.default.statSync(resolved).isDirectory()) {
+        throw new errors_1.CliError(`Not a valid directory: ${resolved}`);
+    }
+    return resolved;
+}
 function parseBusinessCanonOption(value) {
     if (!value || value === 'none' || value === 'skip') {
         return undefined;
     }
+    // Detect local path: starts with /, ./, ../, or ~
+    if (LOCAL_PATH_RE.test(value)) {
+        const resolved = resolveLocalCanonPath(value);
+        return {
+            business: {
+                repo: `local/${node_path_1.default.basename(resolved)}`,
+                branch: 'local',
+                localDir: 'business',
+                source: 'local',
+                localPath: resolved,
+            },
+        };
+    }
+    // GitHub repo: must contain /
     if (!value.includes('/')) {
-        throw new errors_1.CliError(`Invalid business canon format "${value}". Use "owner/repo" or "none" to skip.`);
+        throw new errors_1.CliError(`Invalid business canon format "${value}". Use "owner/repo", a local path, or "none" to skip.`);
     }
     return {
         business: {
             repo: value,
             branch: 'main',
             localDir: 'business',
+            source: 'github',
         },
     };
 }
-async function resolveBusinessCanon(options, logger) {
+async function resolveBusinessCanon(options, config, logger) {
     // CLI flag takes priority
     if (options.businessCanon) {
         return parseBusinessCanonOption(options.businessCanon);
     }
     // --yes without --business-canon: mandatory error
     if (options.yes) {
-        throw new errors_1.CliError('--business-canon is required with --yes. Use --business-canon owner/repo or --business-canon none.');
+        throw new errors_1.CliError('--business-canon is required with --yes. Use --business-canon owner/repo, --business-canon /local/path, or --business-canon none.');
     }
-    // Interactive prompt
-    const repo = await (0, prompt_1.promptText)('Business architecture canon repo (owner/repo, empty to skip):');
-    if (!repo) {
+    // Interactive: choose source
+    const source = await (0, prompt_1.promptChoice)('Business canon source:', [
+        { value: 'github', label: 'GitHub repository (search and select)' },
+        { value: 'local', label: 'Local directory' },
+        { value: 'skip', label: 'Skip (no business canon)' },
+    ], 'skip');
+    if (source === 'skip') {
         logger.info('No business canon configured.');
         return undefined;
     }
-    if (!repo.includes('/')) {
-        throw new errors_1.CliError(`Invalid format "${repo}". Use "owner/repo".`);
+    if (source === 'local') {
+        return resolveLocalBusinessCanon(logger);
+    }
+    return resolveGitHubBusinessCanon(config, logger);
+}
+async function resolveLocalBusinessCanon(logger) {
+    const rawPath = await (0, prompt_1.promptText)('Local canon directory path:');
+    if (!rawPath) {
+        throw new errors_1.CliError('Path is required for local canon.');
+    }
+    const resolved = resolveLocalCanonPath(rawPath);
+    const dirName = node_path_1.default.basename(resolved);
+    logger.info(`Using local canon at ${resolved}`);
+    return {
+        business: {
+            repo: `local/${dirName}`,
+            branch: 'local',
+            localDir: 'business',
+            source: 'local',
+            localPath: resolved,
+        },
+    };
+}
+async function resolveGitHubBusinessCanon(config, logger) {
+    // Ensure GitHub auth
+    const token = await ensureGitHubAuth(config.collabDir, logger);
+    // Search loop
+    let repo;
+    let defaultBranch = 'main';
+    while (!repo) {
+        const query = await (0, prompt_1.promptText)('Search GitHub repositories:');
+        if (!query) {
+            throw new errors_1.CliError('Search query is required.');
+        }
+        const results = await (0, github_search_1.searchGitHubRepos)(query, token, 8);
+        if (results.items.length === 0) {
+            logger.info(`No repositories found for "${query}". Try a different search.`);
+            continue;
+        }
+        logger.info(`Found ${results.items.length} results (of ${results.totalCount} total):`);
+        const choices = results.items.map((r) => ({
+            value: r.fullName,
+            label: `${r.fullName}${r.private ? ' \u{1F512}' : ''}${r.description ? ` — ${r.description}` : ''}`,
+        }));
+        choices.push({ value: '__search_again__', label: '\u21BB Search again' });
+        const selected = await (0, prompt_1.promptChoice)('Select repository:', choices, choices[0].value);
+        if (selected === '__search_again__') {
+            continue;
+        }
+        repo = selected;
+        defaultBranch =
+            results.items.find((r) => r.fullName === selected)?.defaultBranch ?? 'main';
     }
-    const branch = await (0, prompt_1.promptText)('Business canon branch:', 'main');
+    const branch = await (0, prompt_1.promptText)('Branch:', defaultBranch);
     return {
         business: {
             repo,
-            branch: branch || 'main',
+            branch: branch || defaultBranch,
             localDir: 'business',
+            source: 'github',
         },
     };
 }
+async function ensureGitHubAuth(collabDir, logger) {
+    const existing = (0, github_auth_1.loadGitHubAuth)(collabDir);
+    if (existing) {
+        const valid = await (0, github_auth_1.isGitHubAuthValid)(existing);
+        if (valid) {
+            return existing.token;
+        }
+        logger.info('Existing GitHub token expired. Re-authorizing...');
+    }
+    await (0, github_auth_1.runGitHubDeviceFlow)(collabDir, (msg) => logger.info(msg));
+    const auth = (0, github_auth_1.loadGitHubAuth)(collabDir);
+    if (!auth) {
+        throw new errors_1.CliError('GitHub authorization failed.');
+    }
+    return auth.token;
+}
 // ────────────────────────────────────────────────────────────────
 // Shared inline stages used by both pipelines
 // ────────────────────────────────────────────────────────────────
@@ -756,7 +857,7 @@ function registerInitCommand(program) {
         .option('--skip-analysis', 'Skip AI-powered repository analysis stage')
         .option('--skip-ci', 'Skip CI workflow generation')
         .option('--providers <list>', 'Comma-separated AI provider list (codex,claude,gemini,copilot)')
-        .option('--business-canon <owner/repo>', 'Business canon repo (owner/repo or "none" to skip)')
+        .option('--business-canon <value>', 'Business canon: owner/repo, /local/path, or "none" to skip')
         .option('--github-token <token>', 'GitHub token for non-interactive mode')
         .option('--timeout-ms <ms>', 'Per-check timeout in milliseconds', '5000')
         .option('--retries <count>', 'Health check retries', '15')
@@ -818,7 +919,7 @@ Examples:
             mcpUrl: preserveExisting ? context.config.mcpUrl : selections.mcpUrl,
         };
         // ── Step 2: Business canon configuration ──────────────────
-        const canons = await resolveBusinessCanon(options, context.logger);
+        const canons = await resolveBusinessCanon(options, effectiveConfig, context.logger);
         if (canons) {
             effectiveConfig.canons = canons;
         }

package/dist/commands/update-canons.js

@@ -29,19 +29,23 @@ function registerUpdateCanonsCommand(program) {
         }
         // ── Business canon ───────────────────────────────────────
         if ((0, canon_resolver_1.isBusinessCanonConfigured)(context.config)) {
+            const canon = context.config.canons?.business;
             const auth = (0, github_auth_1.loadGitHubAuth)(context.config.collabDir);
             const token = auth?.token;
             const bizOk = (0, canon_resolver_1.syncBusinessCanon)(context.config, (msg) => context.logger.info(msg), token);
             if (!bizOk) {
                 throw new errors_1.CliError('Failed to sync business canon.');
             }
-            const bizDir = (0, canon_resolver_1.getBusinessCanonDir)(context.config);
-            try {
-                const bizCommitInfo = (0, node_child_process_1.execFileSync)('git', ['-C', bizDir, 'log', '-1', `--format=${COMMIT_FORMAT}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-                context.logger.info(`Business canon up to date: ${bizCommitInfo}`);
-            }
-            catch {
-                context.logger.info('Business canon updated successfully.');
+            // Show git log only for GitHub-sourced canons (local dirs may not be git repos)
+            if (canon?.source !== 'local') {
+                const bizDir = (0, canon_resolver_1.getBusinessCanonDir)(context.config);
+                try {
+                    const bizCommitInfo = (0, node_child_process_1.execFileSync)('git', ['-C', bizDir, 'log', '-1', `--format=${COMMIT_FORMAT}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+                    context.logger.info(`Business canon up to date: ${bizCommitInfo}`);
+                }
+                catch {
+                    context.logger.info('Business canon updated successfully.');
+                }
             }
         }
     });

package/dist/lib/canon-resolver.js

@@ -167,13 +167,20 @@ function isBusinessCanonConfigured(config) {
     return !!config.canons?.business?.repo;
 }
 /**
- * Returns the local directory where the business canon is cloned.
+ * Returns the local directory where the business canon lives.
+ * For local canons this is the user-provided path; for GitHub canons
+ * it's the cached clone under `~/.collab/canons/<repo>`.
  */
 function getBusinessCanonDir(config) {
     const canon = config.canons?.business;
     if (!canon) {
         throw new Error('No business canon configured.');
     }
+    // Local source: the user's directory as-is
+    if (canon.source === 'local' && canon.localPath) {
+        return canon.localPath;
+    }
+    // GitHub source: cached clone
     const repoName = canon.repo.split('/').pop() ?? canon.repo;
     const collabHome = process.env.COLLAB_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), '.collab');
     return node_path_1.default.join(collabHome, CANONS_SUBDIR, repoName);
@@ -187,9 +194,18 @@ function syncBusinessCanon(config, log, token) {
     if (!canon) {
         return false;
     }
+    const print = log ?? console.log;
+    // Local canons don't need syncing — just validate the path exists
+    if (canon.source === 'local') {
+        if (!canon.localPath || !node_fs_1.default.existsSync(canon.localPath)) {
+            print(`Local canon path not found: ${canon.localPath ?? '(not set)'}`);
+            return false;
+        }
+        print(`Using local business canon at ${canon.localPath}`);
+        return true;
+    }
     const canonsDir = getBusinessCanonDir(config);
     const parentDir = node_path_1.default.dirname(canonsDir);
-    const print = log ?? console.log;
     const branch = canon.branch || 'main';
     // Build repo URL — inject token for private repo access if available
     let repoUrl;

package/dist/lib/github-search.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGitHubRepos = searchGitHubRepos;
+const errors_1 = require("./errors");
+const GITHUB_API_VERSION = '2022-11-28';
+const SEARCH_TIMEOUT_MS = 15_000;
+/**
+ * Searches GitHub repositories using the REST search API.
+ * Requires a valid GitHub token with `repo` scope for private repos.
+ *
+ * @param query  - Search query (same syntax as GitHub web search)
+ * @param token  - GitHub personal access token or OAuth token
+ * @param limit  - Max results to return (default 8, max 100)
+ */
+async function searchGitHubRepos(query, token, limit = 8) {
+    const encoded = encodeURIComponent(query);
+    const url = `https://api.github.com/search/repositories?q=${encoded}&per_page=${limit}&sort=updated`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/vnd.github+json',
+                'X-GitHub-Api-Version': GITHUB_API_VERSION,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new errors_1.CliError(`GitHub search failed (HTTP ${response.status}): ${body || response.statusText}`);
+        }
+        const data = (await response.json());
+        return {
+            totalCount: data.total_count,
+            items: data.items.map((item) => ({
+                fullName: item.full_name,
+                description: item.description ?? '',
+                private: item.private,
+                defaultBranch: item.default_branch,
+            })),
+        };
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            throw error;
+        }
+        // AbortController fires when the timeout elapses — surface a clear message
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new errors_1.CliError(`GitHub search request timed out after ${SEARCH_TIMEOUT_MS / 1000}s.`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new errors_1.CliError(`GitHub search request failed: ${message}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxmaltech/collab-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "CLI for collaborative architecture and delivery workflows.",
   "private": false,
   "license": "UNLICENSED",