@nemus-cli/nemus 0.2.1

package/dist/utils/repo-resolver.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Fuzzy repository name resolver.
+ *
+ * Resolves user-supplied repo name inputs (which may be partial, mis-spelled,
+ * or differently-cased) to actual repository objects from the full list.
+ *
+ * Scoring ladder (higher = better match):
+ *  100  exact case-sensitive match
+ *   95  case-insensitive exact match
+ *   90  normalised exact match (spaces/underscores → hyphens)
+ *   80  input is a hyphen-boundary prefix of repo name  e.g. "platform" → "platform-app"
+ *   75  repo name is a hyphen-boundary prefix of input
+ *   65  input is a substring of repo name
+ *   60  repo name is a substring of input
+ *   30–50 Levenshtein edit distance ≤ threshold (typo tolerance)
+ *
+ * A match is only returned when score ≥ MIN_SCORE (30).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_SUFFIX = void 0;
+exports.levenshtein = levenshtein;
+exports.damerauLevenshtein = damerauLevenshtein;
+exports.fuzzyFindRepo = fuzzyFindRepo;
+exports.resolveRepoNames = resolveRepoNames;
+exports.parseRepoSpec = parseRepoSpec;
+exports.resolveRepoSpecs = resolveRepoSpecs;
+/** Minimum score required to accept a fuzzy match. */
+const MIN_SCORE = 30;
+/**
+ * Normalise a repo name for comparison:
+ *  - lowercase
+ *  - spaces and underscores → hyphens
+ *  - collapse repeated hyphens
+ */
+function normalise(s) {
+    return s
+        .trim() // strip leading/trailing whitespace first
+        .toLowerCase()
+        .replace(/[\s_]+/g, '-') // spaces and underscores → hyphens
+        .replace(/-{2,}/g, '-') // collapse repeated hyphens
+        .replace(/^-+|-+$/g, ''); // strip any leading/trailing hyphens
+}
+/**
+ * Compute the Levenshtein edit distance between two strings.
+ */
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    // Use two alternating rows to keep memory O(n)
+    let prev = Array.from({ length: n + 1 }, (_, j) => j);
+    let curr = new Array(n + 1);
+    for (let i = 1; i <= m; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= n; j++) {
+            curr[j] =
+                a[i - 1] === b[j - 1]
+                    ? prev[j - 1]
+                    : 1 + Math.min(prev[j - 1], prev[j], curr[j - 1]);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[n];
+}
+/**
+ * Damerau-Levenshtein distance (Optimal String Alignment variant).
+ *
+ * Like {@link levenshtein} but an ADJACENT TRANSPOSITION counts as a single
+ * edit — so "capser" ↔ "casper" is distance 1, not 2. Transposing two
+ * neighbouring characters is the most common human typo, so this is what we
+ * use for typo-tolerant repo matching. Names are short, so the full O(mn)
+ * matrix is negligible.
+ */
+function damerauLevenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const d = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        d[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            d[i][j] = Math.min(d[i - 1][j] + 1, // deletion
+            d[i][j - 1] + 1, // insertion
+            d[i - 1][j - 1] + cost);
+            // Adjacent transposition: a[i-1] a[i-2] == b[j-2] b[j-1]
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+            }
+        }
+    }
+    return d[m][n];
+}
+/**
+ * Score how well `originalInput` matches `originalRepo`.
+ * All normalisation is done here so the scoring ladder is fully reachable.
+ */
+function scoreMatch(originalInput, originalRepo) {
+    // Exact (case-sensitive)
+    if (originalRepo === originalInput)
+        return 100;
+    // Case-insensitive exact
+    if (originalRepo.toLowerCase() === originalInput.toLowerCase())
+        return 95;
+    // Normalised exact (spaces/underscores → hyphens; reachable for e.g. "my_app" or "my app")
+    const normInput = normalise(originalInput);
+    const normRepo = normalise(originalRepo);
+    if (normRepo === normInput)
+        return 90;
+    // Prefix: normInput is a hyphen-boundary prefix of normRepo
+    // e.g. "platform" → "platform-app"
+    if (normRepo.startsWith(normInput + '-'))
+        return 80;
+    // Prefix: normRepo is a hyphen-boundary prefix of normInput
+    if (normInput.startsWith(normRepo + '-'))
+        return 75;
+    // Substring: normInput appears inside normRepo
+    if (normRepo.includes(normInput))
+        return 65;
+    // Substring: normRepo appears inside normInput
+    if (normInput.includes(normRepo))
+        return 60;
+    // Token-level match: split by hyphens and see how many tokens overlap
+    const inputTokens = normInput.split('-').filter(Boolean);
+    const repoTokens = normRepo.split('-').filter(Boolean);
+    if (inputTokens.length > 0 && repoTokens.length > 0) {
+        let matched = 0;
+        for (const it of inputTokens) {
+            if (repoTokens.some(rt => rt === it || rt.startsWith(it) || it.startsWith(rt))) {
+                matched++;
+            }
+        }
+        if (matched > 0) {
+            const tokenScore = Math.round((matched / Math.max(inputTokens.length, repoTokens.length)) * 55);
+            if (tokenScore >= MIN_SCORE)
+                return tokenScore;
+        }
+    }
+    // Typo tolerance — Damerau-Levenshtein so an adjacent transposition
+    // (e.g. "capser" → "casper") counts as a single edit.
+    const dist = damerauLevenshtein(normInput, normRepo);
+    // Allow more edits for longer names (up to 3, never more)
+    const maxDist = Math.min(3, Math.floor(Math.max(normInput.length, normRepo.length) * 0.25));
+    if (dist <= maxDist && maxDist > 0) {
+        return Math.max(MIN_SCORE, 50 - dist * 10);
+    }
+    return 0;
+}
+/**
+ * Find the best-matching repo from `allRepos` for a given user-supplied `input`.
+ *
+ * @param input    The repo name as typed/extracted (may be partial or mis-spelled).
+ * @param allRepos Full list of available repositories (must have a `.name` string field).
+ * @returns        The best match and its score, or `null` if no match is good enough.
+ */
+function fuzzyFindRepo(input, allRepos) {
+    if (!input || allRepos.length === 0)
+        return null;
+    // Inputs like "_", "-", or "   " normalise to ""; String#includes('') is
+    // always true, so they would match every repo. Reject them early.
+    if (!normalise(input))
+        return null;
+    let best = null;
+    for (const repo of allRepos) {
+        const score = scoreMatch(input, repo.name);
+        if (score > 0 && (!best || score > best.score)) {
+            best = { repo, score, exact: score >= 90 };
+        }
+    }
+    if (best && best.score >= MIN_SCORE)
+        return best;
+    return null;
+}
+/**
+ * Resolve an array of user-supplied repo name inputs against the full repo list.
+ *
+ * Returns:
+ *  - `resolved`: array of `{ input, repo, exact }` for each successfully matched name
+ *  - `notFound`:  array of input strings that had no good match
+ */
+function resolveRepoNames(inputs, allRepos) {
+    const resolved = [];
+    const notFound = [];
+    // Deduplicate: if two inputs fuzzy-resolve to the same repo, keep only the first.
+    const seen = new Set();
+    for (const input of inputs) {
+        const match = fuzzyFindRepo(input, allRepos);
+        if (match) {
+            if (!seen.has(match.repo.name)) {
+                seen.add(match.repo.name);
+                resolved.push({ input, repo: match.repo, exact: match.exact });
+            }
+            // else: duplicate resolution — silently skip (first wins)
+        }
+        else {
+            notFound.push(input);
+        }
+    }
+    return { resolved, notFound };
+}
+/** Suffix charset shared with the MCP update_workspace tool (name-suffix dir). */
+exports.VALID_SUFFIX = /^[a-zA-Z0-9_-]+$/;
+/**
+ * Parse a single `--repos` entry that may carry an instance suffix.
+ *
+ * The same repository can be added to a workspace more than once by giving
+ * each copy a distinct suffix, e.g. a git-worktree-style second checkout:
+ *
+ *   "casper"            -> { name: "casper" }                  (dir: casper)
+ *   "casper:cas-101"    -> { name: "casper", suffix: "cas-101"} (dir: casper-cas-101)
+ *
+ * This mirrors the MCP `update_workspace` tool's `{ name, suffix }` shape so
+ * the CLI and agent paths behave identically.
+ */
+function parseRepoSpec(spec) {
+    const trimmed = spec.trim();
+    const idx = trimmed.indexOf(':');
+    if (idx > 0) {
+        const name = trimmed.slice(0, idx).trim();
+        const suffix = trimmed.slice(idx + 1).trim();
+        return suffix ? { name, suffix } : { name };
+    }
+    return { name: trimmed };
+}
+/**
+ * Resolve an array of `--repos` specs (each possibly `name:suffix`) into repo
+ * entries with their target directory names. Unlike {@link resolveRepoNames},
+ * this dedupes by the final **directory name**, so the same repo can appear
+ * multiple times under different suffixes.
+ */
+function resolveRepoSpecs(inputs, allRepos) {
+    const resolved = [];
+    const notFound = [];
+    const invalidSuffix = [];
+    const seenDirs = new Set();
+    for (const input of inputs) {
+        const spec = parseRepoSpec(input);
+        if (spec.suffix !== undefined && !exports.VALID_SUFFIX.test(spec.suffix)) {
+            invalidSuffix.push(input);
+            continue;
+        }
+        const match = fuzzyFindRepo(spec.name, allRepos);
+        if (!match) {
+            notFound.push(spec.name);
+            continue;
+        }
+        const directoryName = spec.suffix ? `${match.repo.name}-${spec.suffix}` : match.repo.name;
+        if (seenDirs.has(directoryName))
+            continue; // duplicate target dir within this batch
+        seenDirs.add(directoryName);
+        resolved.push({ input, repo: match.repo, exact: match.exact, suffix: spec.suffix, directoryName });
+    }
+    return { resolved, notFound, invalidSuffix };
+}

package/dist/utils/retry.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRetryableError = isRetryableError;
+exports.withRetry = withRetry;
+const logger_1 = require("./logger");
+const DEFAULT_OPTIONS = {
+    maxRetries: 1,
+    initialDelayMs: 2000,
+    backoffMultiplier: 2,
+    maxDelayMs: 10000,
+};
+const NON_RETRYABLE_PATTERNS = [
+    'authentication failed',
+    'permission denied',
+    'repository not found',
+    'could not read from remote repository',
+    '401',
+    '403',
+    '404',
+];
+const RETRYABLE_PATTERNS = [
+    'timeout',
+    'etimedout',
+    'econnrefused',
+    'econnreset',
+    'enotfound',
+];
+function isRetryableError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    for (const pattern of NON_RETRYABLE_PATTERNS) {
+        if (message.includes(pattern)) {
+            return false;
+        }
+    }
+    for (const pattern of RETRYABLE_PATTERNS) {
+        if (message.includes(pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function withRetry(operation, options, operationName) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lastError;
+    let delay = opts.initialDelayMs;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= opts.maxRetries || !isRetryableError(error)) {
+                throw error;
+            }
+            const name = operationName || 'operation';
+            (0, logger_1.logWarning)(`${name} failed (attempt ${attempt + 1}/${opts.maxRetries + 1}), retrying in ${(delay / 1000).toFixed(1)}s...`);
+            await sleep(delay);
+            delay = Math.min(delay * opts.backoffMultiplier, opts.maxDelayMs);
+        }
+    }
+    throw lastError;
+}

package/dist/utils/run-operations.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInRepo = runInRepo;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const COMMAND_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+async function runInRepo(repoPath, repoName, command) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: repoPath,
+            timeout: COMMAND_TIMEOUT,
+        });
+        return {
+            repo: repoName,
+            status: 'success',
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+        };
+    }
+    catch (error) {
+        return {
+            repo: repoName,
+            status: 'failed',
+            stdout: error.stdout?.trim() || '',
+            stderr: error.stderr?.trim() || '',
+            error: error.message,
+        };
+    }
+}

package/dist/utils/suite.js

@@ -0,0 +1,159 @@
+"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.loadSuitesStore = loadSuitesStore;
+exports.saveSuitesStore = saveSuitesStore;
+exports.listSuites = listSuites;
+exports.getSuite = getSuite;
+exports.saveSuite = saveSuite;
+exports.deleteSuite = deleteSuite;
+exports.exportSuite = exportSuite;
+exports.exportAllSuites = exportAllSuites;
+exports.importSuites = importSuites;
+exports.validateSuiteName = validateSuiteName;
+const fs = __importStar(require("fs/promises"));
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const SUITE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+async function ensureCacheDir() {
+    try {
+        await fs.mkdir(config_1.CACHE_DIR, { recursive: true });
+    }
+    catch {
+        (0, logger_1.logWarning)('Failed to create cache directory');
+    }
+}
+async function loadSuitesStore() {
+    try {
+        const content = await fs.readFile(config_1.SUITES_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { version: 1, suites: [] };
+    }
+}
+async function saveSuitesStore(store) {
+    await ensureCacheDir();
+    await fs.writeFile(config_1.SUITES_FILE, JSON.stringify(store, null, 2), 'utf-8');
+}
+async function listSuites() {
+    const store = await loadSuitesStore();
+    return store.suites.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function getSuite(name) {
+    const store = await loadSuitesStore();
+    return store.suites.find(s => s.name === name);
+}
+async function saveSuite(suite) {
+    const store = await loadSuitesStore();
+    const existingIndex = store.suites.findIndex(s => s.name === suite.name);
+    if (existingIndex >= 0) {
+        store.suites[existingIndex] = suite;
+    }
+    else {
+        store.suites.push(suite);
+    }
+    await saveSuitesStore(store);
+}
+async function deleteSuite(name) {
+    const store = await loadSuitesStore();
+    const index = store.suites.findIndex(s => s.name === name);
+    if (index < 0) {
+        return false;
+    }
+    store.suites.splice(index, 1);
+    await saveSuitesStore(store);
+    return true;
+}
+async function exportSuite(name) {
+    const suite = await getSuite(name);
+    if (!suite) {
+        return null;
+    }
+    return { version: 1, suites: [suite] };
+}
+async function exportAllSuites() {
+    const store = await loadSuitesStore();
+    return { version: 1, suites: store.suites };
+}
+async function importSuites(data, overwrite) {
+    const result = { imported: [], skipped: [], errors: [] };
+    const store = await loadSuitesStore();
+    for (const suite of data.suites) {
+        const nameValidation = validateSuiteName(suite.name);
+        if (nameValidation !== true) {
+            result.errors.push(`${suite.name}: ${nameValidation}`);
+            continue;
+        }
+        if (!Array.isArray(suite.entries)) {
+            result.errors.push(`${suite.name}: missing or invalid entries`);
+            continue;
+        }
+        const hasInvalidEntries = suite.entries.some(e => !e.repoName || typeof e.repoName !== 'string' || !e.directoryName || typeof e.directoryName !== 'string');
+        if (hasInvalidEntries) {
+            result.errors.push(`${suite.name}: entries contain invalid repoName or directoryName values`);
+            continue;
+        }
+        const existingIndex = store.suites.findIndex(s => s.name === suite.name);
+        if (existingIndex >= 0 && !overwrite) {
+            result.skipped.push(suite.name);
+            continue;
+        }
+        if (existingIndex >= 0) {
+            store.suites[existingIndex] = suite;
+        }
+        else {
+            store.suites.push(suite);
+        }
+        result.imported.push(suite.name);
+    }
+    await saveSuitesStore(store);
+    return result;
+}
+function validateSuiteName(name) {
+    if (!name || name.trim().length === 0) {
+        return 'Suite name cannot be empty';
+    }
+    if (!SUITE_NAME_REGEX.test(name)) {
+        return 'Suite name must contain only alphanumeric characters, hyphens, and underscores';
+    }
+    if (name.length < 2) {
+        return 'Suite name must be at least 2 characters long';
+    }
+    if (name.length > 50) {
+        return 'Suite name must be 50 characters or less';
+    }
+    return true;
+}

package/dist/utils/sync-operations.js

@@ -0,0 +1,107 @@
+"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.syncRepository = syncRepository;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const logger_1 = require("./logger");
+const colors_1 = require("./colors");
+const retry_1 = require("./retry");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+async function syncRepository(repoPath, repoName, silent = false) {
+    try {
+        // Check if directory exists
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Directory not found',
+            };
+        }
+        // Check if it's a git repository
+        try {
+            await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+        }
+        catch {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Not a git repository',
+            };
+        }
+        // Check for uncommitted changes
+        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: repoPath });
+        if (statusOutput.trim().length > 0) {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Uncommitted changes',
+            };
+        }
+        // Get current branch
+        const { stdout: branchOutput } = await execAsync('git branch --show-current', { cwd: repoPath });
+        const currentBranch = branchOutput.trim();
+        if (!currentBranch) {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Detached HEAD state',
+            };
+        }
+        if (!silent)
+            (0, logger_1.logInfo)(`Pulling ${(0, colors_1.colorize)(repoName, 'cyan')} (${currentBranch})...`);
+        // Git pull with retry
+        await (0, retry_1.withRetry)(() => execAsync('git pull', { cwd: repoPath, timeout: 60000 }), undefined, `Pull ${repoName}`);
+        if (!silent)
+            (0, logger_1.logSuccess)(`Updated ${(0, colors_1.colorize)(repoName, 'cyan')}`);
+        return {
+            repo: repoName,
+            status: 'success',
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        (0, logger_1.logError)(`Failed to sync ${(0, colors_1.colorize)(repoName, 'cyan')}: ${errorMessage}`);
+        return {
+            repo: repoName,
+            status: 'failed',
+            message: errorMessage,
+        };
+    }
+}