@uxmaltech/collab-cli 0.1.0

package/dist/lib/prompt.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptChoice = promptChoice;
+exports.promptBoolean = promptBoolean;
+exports.promptMultiSelect = promptMultiSelect;
+exports.promptText = promptText;
+exports.promptPassword = promptPassword;
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_process_1 = require("node:process");
+async function promptChoice(question, choices, defaultValue) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const menu = choices
+            .map((choice, index) => {
+            const marker = choice.value === defaultValue ? ' (default)' : '';
+            return `${index + 1}. ${choice.label}${marker}`;
+        })
+            .join('\n');
+        const answer = await rl.question(`${question}\n${menu}\n> `);
+        const trimmed = answer.trim();
+        if (!trimmed) {
+            return defaultValue;
+        }
+        const index = Number.parseInt(trimmed, 10);
+        if (!Number.isNaN(index) && index >= 1 && index <= choices.length) {
+            return choices[index - 1].value;
+        }
+        const byValue = choices.find((choice) => choice.value === trimmed);
+        if (byValue) {
+            return byValue.value;
+        }
+        return defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptBoolean(question, defaultValue) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const suffix = defaultValue ? '[Y/n]' : '[y/N]';
+        const answer = await rl.question(`${question} ${suffix} `);
+        const trimmed = answer.trim().toLowerCase();
+        if (!trimmed) {
+            return defaultValue;
+        }
+        if (trimmed === 'y' || trimmed === 'yes') {
+            return true;
+        }
+        if (trimmed === 'n' || trimmed === 'no') {
+            return false;
+        }
+        return defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptMultiSelect(question, choices, defaults = []) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const defaultSet = new Set(defaults);
+        const menu = choices
+            .map((choice, index) => {
+            const marker = defaultSet.has(choice.value) ? ' (default)' : '';
+            const desc = choice.description ? ` — ${choice.description}` : '';
+            return `${index + 1}. ${choice.label}${desc}${marker}`;
+        })
+            .join('\n');
+        const hint = 'Enter numbers separated by commas, * for all, or empty for defaults';
+        const answer = await rl.question(`${question}\n${menu}\n(${hint})\n> `);
+        const trimmed = answer.trim();
+        if (!trimmed) {
+            return defaults.length > 0 ? [...defaults] : [];
+        }
+        if (trimmed === '*') {
+            return choices.map((c) => c.value);
+        }
+        const selected = [];
+        const parts = trimmed.split(',').map((p) => p.trim());
+        for (const part of parts) {
+            const index = Number.parseInt(part, 10);
+            if (!Number.isNaN(index) && index >= 1 && index <= choices.length) {
+                const value = choices[index - 1].value;
+                if (!selected.includes(value)) {
+                    selected.push(value);
+                }
+                continue;
+            }
+            const byValue = choices.find((c) => c.value === part);
+            if (byValue && !selected.includes(byValue.value)) {
+                selected.push(byValue.value);
+            }
+        }
+        return selected.length > 0 ? selected : defaults.length > 0 ? [...defaults] : [];
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptText(question, defaultValue) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const suffix = defaultValue ? ` (${defaultValue})` : '';
+        const answer = await rl.question(`${question}${suffix}\n> `);
+        const trimmed = answer.trim();
+        return trimmed || defaultValue || '';
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptPassword(question) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const answer = await rl.question(`${question}\n> `);
+        return answer;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/lib/providers.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_DEFAULTS = exports.PROVIDER_KEYS = void 0;
+exports.isProviderKey = isProviderKey;
+exports.parseProviderList = parseProviderList;
+exports.getEnabledProviders = getEnabledProviders;
+exports.autoDetectProviders = autoDetectProviders;
+exports.PROVIDER_KEYS = ['codex', 'claude', 'gemini', 'copilot'];
+exports.PROVIDER_DEFAULTS = {
+    codex: {
+        label: 'Codex (OpenAI)',
+        description: 'OpenAI models via codex CLI or API key',
+        envVar: 'OPENAI_API_KEY',
+        models: ['o3-pro', 'gpt-4.1', 'o4-mini'],
+    },
+    claude: {
+        label: 'Claude (Anthropic)',
+        description: 'Anthropic models via claude CLI or API key',
+        envVar: 'ANTHROPIC_API_KEY',
+        models: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-haiku-35-20241022'],
+    },
+    gemini: {
+        label: 'Gemini (Google)',
+        description: 'Google AI models via gemini CLI or API key',
+        envVar: 'GOOGLE_AI_API_KEY',
+        models: ['gemini-2.5-pro', 'gemini-2.5-flash'],
+    },
+    copilot: {
+        label: 'Copilot (GitHub)',
+        description: 'GitHub Copilot via gh CLI — uses issues assigned to @copilot',
+        envVar: '',
+        models: [],
+    },
+};
+const PROVIDER_SET = new Set(exports.PROVIDER_KEYS);
+function isProviderKey(value) {
+    return PROVIDER_SET.has(value);
+}
+function parseProviderList(value) {
+    const keys = value
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => s.length > 0);
+    const result = [];
+    for (const key of keys) {
+        if (!isProviderKey(key)) {
+            throw new Error(`Invalid provider '${key}'. Valid providers: ${exports.PROVIDER_KEYS.join(', ')}`);
+        }
+        if (!result.includes(key)) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function getEnabledProviders(config) {
+    const assistants = config.assistants;
+    if (!assistants?.providers) {
+        return [];
+    }
+    return exports.PROVIDER_KEYS.filter((key) => assistants.providers[key]?.enabled === true);
+}
+/**
+ * Auto-detects providers from environment variables and installed CLIs.
+ * A provider is detected if its env var is set OR its CLI is on PATH.
+ */
+async function autoDetectProviders() {
+    // Lazy import to avoid circular dependency at module level
+    const { detectProviderCli } = await Promise.resolve().then(() => __importStar(require('./cli-detection')));
+    const detected = [];
+    for (const key of exports.PROVIDER_KEYS) {
+        const defaults = exports.PROVIDER_DEFAULTS[key];
+        // Copilot has no env var — detected only via gh CLI
+        if (defaults.envVar && process.env[defaults.envVar]) {
+            detected.push(key);
+            continue;
+        }
+        // Check if the provider CLI is installed
+        const cli = detectProviderCli(key);
+        if (cli.available) {
+            detected.push(key);
+        }
+    }
+    return detected;
+}

package/dist/lib/repo-analysis-helpers.js

@@ -0,0 +1,379 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLACEHOLDER_MARKER = void 0;
+exports.buildUserMessage = buildUserMessage;
+exports.canOverwrite = canOverwrite;
+exports.extractJson = extractJson;
+exports.sanitizeId = sanitizeId;
+exports.renderAxiom = renderAxiom;
+exports.renderDecision = renderDecision;
+exports.renderConvention = renderConvention;
+exports.renderAntiPattern = renderAntiPattern;
+exports.renderDomain = renderDomain;
+exports.writeAnalysisResults = writeAnalysisResults;
+exports.generateAiHelpers = generateAiHelpers;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.PLACEHOLDER_MARKER = '<!-- AI-GENERATED: PLACEHOLDER -->';
+/**
+ * Builds the user message with the repository context.
+ */
+function buildUserMessage(repoCtx) {
+    const parts = [
+        `# Repository: ${repoCtx.name}`,
+        '',
+        `**Language:** ${repoCtx.language}`,
+        repoCtx.framework ? `**Framework:** ${repoCtx.framework}` : null,
+        `**Source files:** ${repoCtx.totalSourceFiles}`,
+        '',
+        '## Dependencies',
+        repoCtx.dependencies.length > 0
+            ? repoCtx.dependencies.map((d) => `- ${d}`).join('\n')
+            : '_No dependencies detected._',
+        '',
+        '## Key Files',
+        repoCtx.keyFiles.map((f) => `- ${f}`).join('\n'),
+        '',
+        '## Directory Structure',
+        '```',
+        repoCtx.structure,
+        '```',
+        '',
+        'Analyze this repository and generate the canonical architecture documentation.',
+    ];
+    return parts.filter((p) => p !== null).join('\n');
+}
+/**
+ * Checks if a file can be overwritten by the AI analysis.
+ * Only files containing the PLACEHOLDER_MARKER are overwritten.
+ */
+function canOverwrite(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return true;
+    }
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+    return content.includes(exports.PLACEHOLDER_MARKER);
+}
+/**
+ * Extracts JSON from a response that may contain markdown code fences.
+ */
+function extractJson(text) {
+    const fenceMatch = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+    if (fenceMatch) {
+        return fenceMatch[1].trim();
+    }
+    const braceStart = text.indexOf('{');
+    const braceEnd = text.lastIndexOf('}');
+    if (braceStart >= 0 && braceEnd > braceStart) {
+        return text.slice(braceStart, braceEnd + 1);
+    }
+    return text;
+}
+/**
+ * Sanitizes an ID for use as a filename.
+ */
+function sanitizeId(id) {
+    return id.replace(/[^a-zA-Z0-9-]/g, '-');
+}
+/**
+ * Safely coerces an unknown value to a string.
+ * Used for AI-generated JSON fields that may be objects instead of strings.
+ */
+function str(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value == null) {
+        return '';
+    }
+    return JSON.stringify(value);
+}
+function renderAxiom(entry) {
+    return [
+        `# ${entry.id}: ${entry.title}`,
+        '',
+        `**Confidence:** ${entry.confidence ?? 'MEDIUM'}`,
+        `**Verified:** ${new Date().toISOString().split('T')[0]}`,
+        '',
+        '## Statement',
+        '',
+        str(entry.statement ?? entry.title),
+        '',
+        '## Rationale',
+        '',
+        str(entry.rationale ?? '_Not provided._'),
+        '',
+        '## Verification',
+        '',
+        str(entry.verification ?? '_Pending verification._'),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].join('\n');
+}
+function renderDecision(entry) {
+    return [
+        `# ${entry.id}: ${entry.title}`,
+        '',
+        `**Status:** ${str(entry.status ?? 'Accepted')}`,
+        `**Date:** ${new Date().toISOString().split('T')[0]}`,
+        `**Confidence:** ${entry.confidence ?? 'MEDIUM'}`,
+        '',
+        '## Context',
+        '',
+        str(entry.context ?? '_Not provided._'),
+        '',
+        '## Decision',
+        '',
+        str(entry.decision ?? '_Not provided._'),
+        '',
+        '## Consequences',
+        '',
+        str(entry.consequences ?? '_Not provided._'),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].join('\n');
+}
+function renderConvention(entry) {
+    return [
+        `# ${entry.id}: ${entry.title}`,
+        '',
+        `**Confidence:** ${entry.confidence ?? 'MEDIUM'}`,
+        `**Scope:** ${str(entry.scope ?? 'project')}`,
+        '',
+        '## Convention',
+        '',
+        str(entry.convention ?? entry.title),
+        '',
+        '## Examples',
+        '',
+        str(entry.examples ?? '_See codebase._'),
+        '',
+        '## Rationale',
+        '',
+        str(entry.rationale ?? '_Not provided._'),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].join('\n');
+}
+function renderAntiPattern(entry) {
+    return [
+        `# ${entry.id}: ${entry.title}`,
+        '',
+        `**Confidence:** ${entry.confidence ?? 'MEDIUM'}`,
+        `**Severity:** ${str(entry.severity ?? 'warning')}`,
+        '',
+        '## Problem',
+        '',
+        str(entry.problem ?? entry.title),
+        '',
+        '## Why It\'s Harmful',
+        '',
+        str(entry.harm ?? '_Not provided._'),
+        '',
+        '## Alternative',
+        '',
+        str(entry.alternative ?? '_Not provided._'),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].join('\n');
+}
+function renderDomain(entry) {
+    return [
+        `# Domain: ${entry.name}`,
+        '',
+        `**Confidence:** ${entry.confidence ?? 'MEDIUM'}`,
+        '',
+        '## Responsibilities',
+        '',
+        String(entry.responsibilities ?? '_Not provided._'),
+        '',
+        '## Boundaries',
+        '',
+        String(entry.boundaries ?? '_Not provided._'),
+        '',
+        '## Dependencies',
+        '',
+        String(entry.dependencies ?? '_None._'),
+        '',
+        '## Public API',
+        '',
+        String(entry.publicApi ?? '_Not defined._'),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].join('\n');
+}
+/**
+ * Writes analysis results to a base directory.
+ * Used by both indexed (architectureDir) and file-only (repoDir) stages.
+ */
+function writeAnalysisResults(ctx, baseDir, result) {
+    let written = 0;
+    if (result.axioms) {
+        for (const entry of result.axioms) {
+            const filename = `${sanitizeId(entry.id)}-${sanitizeId(entry.title).toLowerCase().slice(0, 40)}.md`;
+            const filePath = node_path_1.default.join(baseDir, 'knowledge', 'axioms', filename);
+            if (canOverwrite(filePath)) {
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(filePath));
+                ctx.executor.writeFile(filePath, renderAxiom(entry), { description: `write axiom ${entry.id}` });
+                written++;
+            }
+        }
+    }
+    if (result.decisions) {
+        for (const entry of result.decisions) {
+            const filename = `${sanitizeId(entry.id)}-${sanitizeId(entry.title).toLowerCase().slice(0, 40)}.md`;
+            const filePath = node_path_1.default.join(baseDir, 'knowledge', 'decisions', filename);
+            if (canOverwrite(filePath)) {
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(filePath));
+                ctx.executor.writeFile(filePath, renderDecision(entry), { description: `write decision ${entry.id}` });
+                written++;
+            }
+        }
+    }
+    if (result.conventions) {
+        for (const entry of result.conventions) {
+            const filename = `${sanitizeId(entry.id)}-${sanitizeId(entry.title).toLowerCase().slice(0, 40)}.md`;
+            const filePath = node_path_1.default.join(baseDir, 'knowledge', 'conventions', filename);
+            if (canOverwrite(filePath)) {
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(filePath));
+                ctx.executor.writeFile(filePath, renderConvention(entry), { description: `write convention ${entry.id}` });
+                written++;
+            }
+        }
+    }
+    if (result.antiPatterns) {
+        for (const entry of result.antiPatterns) {
+            const filename = `${sanitizeId(entry.id)}-${sanitizeId(entry.title).toLowerCase().slice(0, 40)}.md`;
+            const filePath = node_path_1.default.join(baseDir, 'knowledge', 'anti-patterns', filename);
+            if (canOverwrite(filePath)) {
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(filePath));
+                ctx.executor.writeFile(filePath, renderAntiPattern(entry), { description: `write anti-pattern ${entry.id}` });
+                written++;
+            }
+        }
+    }
+    if (result.domains) {
+        for (const entry of result.domains) {
+            const safeName = sanitizeId(entry.name).toLowerCase();
+            const filename = `${safeName}.md`;
+            const filePath = node_path_1.default.join(baseDir, 'domains', filename);
+            if (canOverwrite(filePath)) {
+                ctx.executor.ensureDirectory(node_path_1.default.dirname(filePath));
+                ctx.executor.writeFile(filePath, renderDomain(entry), { description: `write domain ${entry.name}` });
+                written++;
+            }
+        }
+    }
+    ctx.logger.info(`Repository analysis: ${written} architecture file(s) written.`);
+}
+/**
+ * Generates docs/ai/ helper files for fast agent reference.
+ * These are lightweight summaries that prevent agents from scanning the full architecture tree.
+ * Used by both file-only and indexed pipelines.
+ */
+function generateAiHelpers(ctx, repoCtx, analysis) {
+    const aiDir = ctx.config.aiDir;
+    ctx.executor.ensureDirectory(aiDir);
+    // 00_brief.md — one-paragraph project summary
+    const briefContent = [
+        '# Project Brief',
+        '',
+        `**Name:** ${repoCtx.name}`,
+        `**Language:** ${repoCtx.language}`,
+        repoCtx.framework ? `**Framework:** ${repoCtx.framework}` : null,
+        `**Source files:** ${repoCtx.totalSourceFiles}`,
+        '',
+        '## Summary',
+        '',
+        `This is a ${repoCtx.language}${repoCtx.framework ? ` / ${repoCtx.framework}` : ''} project` +
+            ` with ${repoCtx.totalSourceFiles} source files.`,
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ].filter((l) => l !== null).join('\n');
+    ctx.executor.writeFile(node_path_1.default.join(aiDir, '00_brief.md'), briefContent, {
+        description: 'write AI helper: project brief',
+    });
+    // 01_domain_map.md — domain index
+    const domainLines = ['# Domain Map', ''];
+    if (analysis.domains && analysis.domains.length > 0) {
+        for (const d of analysis.domains) {
+            domainLines.push(`## ${d.name}`);
+            domainLines.push('');
+            if (d.responsibilities) {
+                domainLines.push(`**Responsibilities:** ${d.responsibilities}`);
+            }
+            if (d.boundaries) {
+                domainLines.push(`**Boundaries:** ${d.boundaries}`);
+            }
+            domainLines.push('');
+        }
+    }
+    else {
+        domainLines.push('_No domains detected yet. Run repository analysis with an AI provider._');
+        domainLines.push('');
+    }
+    domainLines.push('<!-- AI-GENERATED -->');
+    domainLines.push('');
+    ctx.executor.writeFile(node_path_1.default.join(aiDir, '01_domain_map.md'), domainLines.join('\n'), {
+        description: 'write AI helper: domain map',
+    });
+    // 02_module_map.md — key files and structure
+    const moduleLines = [
+        '# Module Map',
+        '',
+        '## Key Files',
+        '',
+        ...repoCtx.keyFiles.map((f) => `- \`${f}\``),
+        '',
+        '## Directory Structure',
+        '',
+        '```',
+        repoCtx.structure,
+        '```',
+        '',
+        '## Dependencies',
+        '',
+        ...(repoCtx.dependencies.length > 0
+            ? repoCtx.dependencies.map((d) => `- ${d}`)
+            : ['_No dependencies detected._']),
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ];
+    ctx.executor.writeFile(node_path_1.default.join(aiDir, '02_module_map.md'), moduleLines.join('\n'), {
+        description: 'write AI helper: module map',
+    });
+    // _snapshot.md — quick-reference index linking to the other files
+    const snapshotLines = [
+        '# Architecture Snapshot',
+        '',
+        `Generated: ${new Date().toISOString().split('T')[0]}`,
+        '',
+        '## Quick Links',
+        '',
+        '- [Project Brief](./00_brief.md)',
+        '- [Domain Map](./01_domain_map.md)',
+        '- [Module Map](./02_module_map.md)',
+        '',
+        '## Architecture Sources',
+        '',
+        '- `docs/architecture/uxmaltech/` — Institutional canon (collab-architecture copy)',
+        '- `docs/architecture/repo/` — Project-specific canons',
+        '',
+        '<!-- AI-GENERATED -->',
+        '',
+    ];
+    ctx.executor.writeFile(node_path_1.default.join(aiDir, '_snapshot.md'), snapshotLines.join('\n'), {
+        description: 'write AI helper: snapshot index',
+    });
+    ctx.logger.info(`AI helpers: 4 file(s) written to docs/ai/.`);
+}