@uxmaltech/collab-cli 0.1.0

package/dist/lib/repo-scanner.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRepository = scanRepository;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Directories always excluded from scanning. */
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '__pycache__',
+    '.venv',
+    'vendor',
+    'target',
+]);
+/** File extensions considered for context. */
+const SOURCE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.py',
+    '.rs',
+    '.go',
+    '.java',
+    '.rb',
+    '.php',
+    '.vue',
+    '.svelte',
+]);
+const CONFIG_FILES = [
+    'package.json',
+    'tsconfig.json',
+    'Cargo.toml',
+    'composer.json',
+    'go.mod',
+    'Gemfile',
+    'requirements.txt',
+    'pyproject.toml',
+    '.eslintrc.json',
+    '.prettierrc',
+];
+/**
+ * Detects the primary language and framework from manifest files.
+ */
+function detectStack(workspaceDir) {
+    const pkgPath = node_path_1.default.join(workspaceDir, 'package.json');
+    if (node_fs_1.default.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf8'));
+            const deps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {}),
+            };
+            const depNames = Object.keys(deps);
+            const language = depNames.some((d) => d === 'typescript' || d.startsWith('@types/'))
+                ? 'TypeScript'
+                : 'JavaScript';
+            let framework = null;
+            if (depNames.includes('next'))
+                framework = 'Next.js';
+            else if (depNames.includes('nuxt'))
+                framework = 'Nuxt';
+            else if (depNames.includes('react'))
+                framework = 'React';
+            else if (depNames.includes('vue'))
+                framework = 'Vue';
+            else if (depNames.includes('svelte'))
+                framework = 'Svelte';
+            else if (depNames.includes('express'))
+                framework = 'Express';
+            else if (depNames.includes('fastify'))
+                framework = 'Fastify';
+            else if (depNames.includes('commander'))
+                framework = 'CLI (Commander)';
+            return { language, framework, dependencies: depNames.slice(0, 30) };
+        }
+        catch {
+            // Fall through
+        }
+    }
+    const cargoPath = node_path_1.default.join(workspaceDir, 'Cargo.toml');
+    if (node_fs_1.default.existsSync(cargoPath)) {
+        return { language: 'Rust', framework: null, dependencies: [] };
+    }
+    const goModPath = node_path_1.default.join(workspaceDir, 'go.mod');
+    if (node_fs_1.default.existsSync(goModPath)) {
+        return { language: 'Go', framework: null, dependencies: [] };
+    }
+    const pyprojectPath = node_path_1.default.join(workspaceDir, 'pyproject.toml');
+    const requirementsPath = node_path_1.default.join(workspaceDir, 'requirements.txt');
+    if (node_fs_1.default.existsSync(pyprojectPath) || node_fs_1.default.existsSync(requirementsPath)) {
+        return { language: 'Python', framework: null, dependencies: [] };
+    }
+    const composerPath = node_path_1.default.join(workspaceDir, 'composer.json');
+    if (node_fs_1.default.existsSync(composerPath)) {
+        return { language: 'PHP', framework: null, dependencies: [] };
+    }
+    return { language: 'Unknown', framework: null, dependencies: [] };
+}
+/**
+ * Walks the file tree and returns a structured summary.
+ */
+function walkTree(dir, rootDir, depth, maxDepth) {
+    const lines = [];
+    const sourceFiles = [];
+    if (depth > maxDepth) {
+        return { lines, sourceFiles };
+    }
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return { lines, sourceFiles };
+    }
+    // Sort: directories first, then files
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    const indent = '  '.repeat(depth);
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') && depth === 0 && entry.name !== '.github') {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIRS.has(entry.name))
+                continue;
+            lines.push(`${indent}${entry.name}/`);
+            const sub = walkTree(node_path_1.default.join(dir, entry.name), rootDir, depth + 1, maxDepth);
+            lines.push(...sub.lines);
+            sourceFiles.push(...sub.sourceFiles);
+        }
+        else if (entry.isFile()) {
+            const ext = node_path_1.default.extname(entry.name);
+            if (SOURCE_EXTENSIONS.has(ext) || CONFIG_FILES.includes(entry.name)) {
+                const relPath = node_path_1.default.relative(rootDir, node_path_1.default.join(dir, entry.name));
+                sourceFiles.push(relPath);
+                if (depth <= maxDepth) {
+                    lines.push(`${indent}${entry.name}`);
+                }
+            }
+        }
+    }
+    return { lines, sourceFiles };
+}
+/**
+ * Scans a repository and produces a structured context for AI analysis.
+ */
+function scanRepository(workspaceDir, options = {}) {
+    const budgetChars = options.budgetChars ?? 4000;
+    const repoName = node_path_1.default.basename(workspaceDir);
+    const stack = detectStack(workspaceDir);
+    const { lines, sourceFiles } = walkTree(workspaceDir, workspaceDir, 0, 4);
+    // Trim structure to budget
+    let structure = lines.join('\n');
+    if (structure.length > budgetChars) {
+        structure = structure.slice(0, budgetChars) + '\n... (truncated)';
+    }
+    // Identify key files (entry points, configs, main modules)
+    const keyFilePatterns = [
+        /^src\/index\.\w+$/,
+        /^src\/main\.\w+$/,
+        /^src\/app\.\w+$/,
+        /^index\.\w+$/,
+        /^main\.\w+$/,
+        /package\.json$/,
+        /tsconfig\.json$/,
+        /README\.md$/i,
+    ];
+    const keyFiles = sourceFiles
+        .filter((f) => keyFilePatterns.some((p) => p.test(f)))
+        .slice(0, 10);
+    return {
+        name: repoName,
+        language: stack.language,
+        framework: stack.framework,
+        dependencies: stack.dependencies,
+        structure,
+        keyFiles,
+        totalSourceFiles: sourceFiles.length,
+    };
+}

package/dist/lib/service-health.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REBUILD_HEALTH_OPTIONS = void 0;
+exports.loadRuntimeEnv = loadRuntimeEnv;
+exports.waitForInfraHealth = waitForInfraHealth;
+exports.waitForMcpHealth = waitForMcpHealth;
+exports.logServiceHealth = logServiceHealth;
+exports.dryRunHealthOptions = dryRunHealthOptions;
+const compose_defaults_1 = require("./compose-defaults");
+const env_file_1 = require("./env-file");
+const health_checker_1 = require("./health-checker");
+/**
+ * Default health-check options used by standalone canon-rebuild stages
+ * that need to verify MCP reachability before calling API endpoints.
+ */
+exports.REBUILD_HEALTH_OPTIONS = {
+    timeoutMs: 5_000,
+    retries: 3,
+    retryDelayMs: 1_000,
+};
+function parsePort(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed < 1 || parsed > 65_535) {
+        return fallback;
+    }
+    return parsed;
+}
+function loadRuntimeEnv(config) {
+    const existing = (0, env_file_1.readEnvFile)(config.envFile);
+    return (0, env_file_1.mergeEnvWithDefaults)(existing, compose_defaults_1.COMPOSE_ENV_DEFAULTS);
+}
+async function waitForInfraHealth(env, options) {
+    const qdrantHost = env.QDRANT_HOST || '127.0.0.1';
+    const qdrantPort = parsePort(env.QDRANT_PORT, 6333);
+    const nebulaHost = env.NEBULA_HOST || '127.0.0.1';
+    const nebulaPort = parsePort(env.NEBULA_GRAPHD_PORT, 9669);
+    const qdrant = await (0, health_checker_1.checkHttpHealth)('qdrant', `http://${qdrantHost}:${qdrantPort}/collections`, options);
+    const nebula = await (0, health_checker_1.checkTcpHealth)('nebula-graphd', nebulaHost, nebulaPort, options);
+    const checks = [qdrant, nebula];
+    return {
+        ok: checks.every((item) => item.ok),
+        checks: checks.filter((item) => item.ok).map((item) => item.detail),
+        errors: checks
+            .filter((item) => !item.ok)
+            .map((item) => `${item.name}: ${item.error ?? item.detail}`),
+    };
+}
+async function waitForMcpHealth(env, options) {
+    const host = env.MCP_HOST || '127.0.0.1';
+    const port = parsePort(env.MCP_PORT, 7337);
+    const mcp = await (0, health_checker_1.checkHttpHealth)('mcp', `http://${host}:${port}/health`, options);
+    return {
+        ok: mcp.ok,
+        checks: mcp.ok ? [mcp.detail] : [],
+        errors: mcp.ok ? [] : [`${mcp.name}: ${mcp.error ?? mcp.detail}`],
+    };
+}
+function logServiceHealth(logger, title, summary) {
+    if (summary.ok) {
+        logger.result(`[PASS] ${title}`);
+        for (const line of summary.checks) {
+            logger.result(`       ${line}`);
+        }
+        return;
+    }
+    logger.result(`[FAIL] ${title}`);
+    for (const line of summary.errors) {
+        logger.result(`       ${line}`);
+    }
+}
+function dryRunHealthOptions(executor, options) {
+    return {
+        ...options,
+        dryRun: executor.dryRun,
+    };
+}

package/dist/lib/shell.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.resolveCommandPath = resolveCommandPath;
+exports.shellQuote = shellQuote;
+exports.toShellCommand = toShellCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Checks whether the file at `filePath` has the execute permission. */
+function isExecutable(filePath) {
+    try {
+        node_fs_1.default.accessSync(filePath, node_fs_1.default.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Searches `$PATH` for an executable named `commandName`.
+ * Returns the full path on success, or `null` when not found.
+ */
+function resolveCommandPath(commandName) {
+    const pathEnv = process.env.PATH ?? '';
+    const directories = pathEnv.split(node_path_1.default.delimiter).filter(Boolean);
+    for (const directory of directories) {
+        const fullPath = node_path_1.default.join(directory, commandName);
+        if (node_fs_1.default.existsSync(fullPath) && isExecutable(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+/**
+ * Wraps `argument` in single-quotes if it contains shell-special characters.
+ * Safe arguments (alphanumeric + common punctuation) are returned as-is.
+ */
+function shellQuote(argument) {
+    if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(argument)) {
+        return argument;
+    }
+    return `'${argument.replace(/'/g, `'"'"'`)}'`;
+}
+/** Joins an argument list into a shell-safe command string. */
+function toShellCommand(parts) {
+    return parts.map((part) => shellQuote(part)).join(' ');
+}

package/dist/lib/state.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.toStateKey = toStateKey;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const EMPTY_STATE = {
+    generatedFiles: {},
+    workflows: {},
+};
+function loadState(config) {
+    if (!node_fs_1.default.existsSync(config.stateFile)) {
+        return { ...EMPTY_STATE };
+    }
+    const raw = node_fs_1.default.readFileSync(config.stateFile, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+        generatedFiles: parsed.generatedFiles ?? {},
+        workflows: parsed.workflows ?? {},
+    };
+}
+function saveState(config, state, executor) {
+    const content = `${JSON.stringify(state, null, 2)}\n`;
+    if (executor) {
+        executor.writeFile(config.stateFile, content, { description: 'write state file' });
+        return;
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(config.stateFile), { recursive: true });
+    node_fs_1.default.writeFileSync(config.stateFile, content, 'utf8');
+}
+function toStateKey(config, filePath) {
+    const relative = node_path_1.default.relative(config.workspaceDir, filePath);
+    return relative === '' ? node_path_1.default.basename(filePath) : relative;
+}

package/dist/lib/update-checker.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCheckState = readCheckState;
+exports.writeCheckState = writeCheckState;
+exports.shouldCheck = shouldCheck;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.checkForUpdate = checkForUpdate;
+exports.maybeNotifyUpdate = maybeNotifyUpdate;
+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 semver_1 = __importDefault(require("semver"));
+const version_1 = require("./version");
+const NPM_PACKAGE_NAME = '@uxmaltech/collab-cli';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 5_000;
+// ── State file helpers ──────────────────────────────────────────────
+function getCheckFilePath() {
+    const collabHome = process.env.COLLAB_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), '.collab');
+    return node_path_1.default.join(collabHome, 'update-check.json');
+}
+function readCheckState(filePath) {
+    const target = filePath ?? getCheckFilePath();
+    try {
+        const raw = node_fs_1.default.readFileSync(target, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastCheck === 'string' && typeof parsed.latestVersion === 'string') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCheckState(state, filePath) {
+    const target = filePath ?? getCheckFilePath();
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(target), { recursive: true });
+    node_fs_1.default.writeFileSync(target, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+function shouldCheck(state) {
+    if (!state)
+        return true;
+    const elapsed = Date.now() - Date.parse(state.lastCheck);
+    return elapsed > CHECK_INTERVAL_MS;
+}
+// ── Registry fetch ──────────────────────────────────────────────────
+async function fetchLatestVersion(packageName) {
+    const name = packageName ?? NPM_PACKAGE_NAME;
+    const url = `https://registry.npmjs.org/${name}/latest`;
+    try {
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok)
+            return null;
+        const payload = (await response.json());
+        if (typeof payload.version === 'string' && payload.version.length > 0) {
+            return payload.version;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Update check ────────────────────────────────────────────────────
+async function checkForUpdate(stateFilePath) {
+    try {
+        const currentVersion = (0, version_1.readCliVersion)();
+        const latestVersion = await fetchLatestVersion();
+        if (!latestVersion)
+            return null;
+        const state = {
+            lastCheck: new Date().toISOString(),
+            latestVersion,
+        };
+        writeCheckState(state, stateFilePath);
+        return {
+            updateAvailable: semver_1.default.gt(latestVersion, currentVersion),
+            currentVersion,
+            latestVersion,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Daily notification banner ───────────────────────────────────────
+async function maybeNotifyUpdate() {
+    try {
+        const state = readCheckState();
+        if (shouldCheck(state)) {
+            const result = await checkForUpdate();
+            if (result?.updateAvailable) {
+                printUpdateBanner(result.currentVersion, result.latestVersion);
+            }
+            return;
+        }
+        // If we have a cached state that indicates an update is available,
+        // show the banner even if we don't re-check
+        if (state) {
+            const currentVersion = (0, version_1.readCliVersion)();
+            if (semver_1.default.gt(state.latestVersion, currentVersion)) {
+                printUpdateBanner(currentVersion, state.latestVersion);
+            }
+        }
+    }
+    catch {
+        // Silent failure — update check should never break the CLI
+    }
+}
+function printUpdateBanner(currentVersion, latestVersion) {
+    const line1 = `  Update available: ${currentVersion} → ${latestVersion}`;
+    const line2 = '  Run: npm install -g @uxmaltech/collab-cli';
+    const line3 = '  Or:  collab upgrade';
+    const maxLen = Math.max(line1.length, line2.length, line3.length);
+    const border = '─'.repeat(maxLen + 2);
+    process.stderr.write('\n');
+    process.stderr.write(`╭${border}╮\n`);
+    process.stderr.write(`│${line1.padEnd(maxLen + 2)}│\n`);
+    process.stderr.write(`│${line2.padEnd(maxLen + 2)}│\n`);
+    process.stderr.write(`│${line3.padEnd(maxLen + 2)}│\n`);
+    process.stderr.write(`╰${border}╯\n`);
+    process.stderr.write('\n');
+}

package/dist/lib/version.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCliVersion = readCliVersion;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Resolved path to the CLI's own package.json. */
+const PACKAGE_JSON_PATH = node_path_1.default.resolve(__dirname, '../../package.json');
+/**
+ * Reads the CLI version from the CLI's own `package.json`.
+ * Returns `'0.0.0'` when the file cannot be read or parsed.
+ */
+function readCliVersion() {
+    try {
+        const raw = node_fs_1.default.readFileSync(PACKAGE_JSON_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === 'string' && parsed.version.length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // Fall back to a neutral value when package metadata cannot be read.
+    }
+    return '0.0.0';
+}