gitnexushub 0.2.1

package/dist/editors/opencode.js

@@ -0,0 +1,83 @@
+/**
+ * OpenCode Editor Setup
+ *
+ * Writes MCP config to ~/.config/opencode/config.json (under `mcp` key)
+ * Installs skills to ~/.config/opencode/skill/
+ */
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { readJsonFile, writeJsonFile } from '../utils.js';
+import { HUB_SKILLS } from '../content.js';
+function getMcpConfig(hubUrl, token) {
+    return {
+        type: 'streamable-http',
+        url: `${hubUrl}/mcp`,
+        headers: { Authorization: `Bearer ${token}` },
+    };
+}
+async function configure(hubUrl, token) {
+    const configPath = path.join(os.homedir(), '.config', 'opencode', 'config.json');
+    try {
+        const existing = (await readJsonFile(configPath)) || {};
+        if (!existing.mcp || typeof existing.mcp !== 'object') {
+            existing.mcp = {};
+        }
+        existing.mcp.gitnexus = getMcpConfig(hubUrl, token);
+        await writeJsonFile(configPath, existing);
+        return { success: true, message: 'MCP configured in ~/.config/opencode/config.json' };
+    }
+    catch (err) {
+        return { success: false, message: `Failed: ${err.message}` };
+    }
+}
+async function installSkills(skills) {
+    const skillsDir = path.join(os.homedir(), '.config', 'opencode', 'skill');
+    let installed = 0;
+    for (const skill of skills) {
+        try {
+            const skillDir = path.join(skillsDir, skill.name);
+            await fs.mkdir(skillDir, { recursive: true });
+            await fs.writeFile(path.join(skillDir, 'SKILL.md'), skill.content, 'utf-8');
+            installed++;
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    return installed;
+}
+async function unconfigure() {
+    const configPath = path.join(os.homedir(), '.config', 'opencode', 'config.json');
+    try {
+        const existing = await readJsonFile(configPath);
+        if (existing?.mcp?.gitnexus) {
+            delete existing.mcp.gitnexus;
+            await writeJsonFile(configPath, existing);
+        }
+        return { success: true, message: 'MCP removed from ~/.config/opencode/config.json' };
+    }
+    catch (err) {
+        return { success: false, message: `Failed: ${err.message}` };
+    }
+}
+async function removeSkills() {
+    const skillsDir = path.join(os.homedir(), '.config', 'opencode', 'skill');
+    let removed = 0;
+    for (const name of HUB_SKILLS) {
+        try {
+            await fs.rm(path.join(skillsDir, name), { recursive: true, force: true });
+            removed++;
+        }
+        catch { /* already gone */ }
+    }
+    return removed;
+}
+export const opencodeEditor = {
+    id: 'opencode',
+    name: 'OpenCode',
+    configure,
+    unconfigure,
+    installSkills,
+    removeSkills,
+};

package/dist/editors/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Editor Types
+ */
+export type EditorId = 'claude-code' | 'cursor' | 'windsurf' | 'opencode';
+export interface EditorConfig {
+    id: EditorId;
+    name: string;
+    configure: (hubUrl: string, token: string) => Promise<ConfigureResult>;
+    unconfigure: () => Promise<ConfigureResult>;
+    installSkills?: (skills: Array<{
+        name: string;
+        content: string;
+    }>) => Promise<number>;
+    removeSkills?: () => Promise<number>;
+}
+export interface ConfigureResult {
+    success: boolean;
+    message: string;
+}

package/dist/editors/types.js

@@ -0,0 +1,4 @@
+/**
+ * Editor Types
+ */
+export {};

package/dist/editors/windsurf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Windsurf Editor Setup
+ *
+ * Writes MCP config to ~/.codeium/windsurf/mcp_config.json
+ * Installs skills to ~/.codeium/windsurf/skills/
+ */
+import type { EditorConfig } from './types.js';
+export declare const windsurfEditor: EditorConfig;

package/dist/editors/windsurf.js

@@ -0,0 +1,83 @@
+/**
+ * Windsurf Editor Setup
+ *
+ * Writes MCP config to ~/.codeium/windsurf/mcp_config.json
+ * Installs skills to ~/.codeium/windsurf/skills/
+ */
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { readJsonFile, writeJsonFile } from '../utils.js';
+import { HUB_SKILLS } from '../content.js';
+function getMcpConfig(hubUrl, token) {
+    return {
+        type: 'streamable-http',
+        url: `${hubUrl}/mcp`,
+        headers: { Authorization: `Bearer ${token}` },
+    };
+}
+async function configure(hubUrl, token) {
+    const mcpPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    try {
+        const existing = (await readJsonFile(mcpPath)) || {};
+        if (!existing.mcpServers || typeof existing.mcpServers !== 'object') {
+            existing.mcpServers = {};
+        }
+        existing.mcpServers.gitnexus = getMcpConfig(hubUrl, token);
+        await writeJsonFile(mcpPath, existing);
+        return { success: true, message: 'MCP configured in ~/.codeium/windsurf/mcp_config.json' };
+    }
+    catch (err) {
+        return { success: false, message: `Failed: ${err.message}` };
+    }
+}
+async function installSkills(skills) {
+    const skillsDir = path.join(os.homedir(), '.codeium', 'windsurf', 'skills');
+    let installed = 0;
+    for (const skill of skills) {
+        try {
+            const skillDir = path.join(skillsDir, skill.name);
+            await fs.mkdir(skillDir, { recursive: true });
+            await fs.writeFile(path.join(skillDir, 'SKILL.md'), skill.content, 'utf-8');
+            installed++;
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    return installed;
+}
+async function unconfigure() {
+    const mcpPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    try {
+        const existing = await readJsonFile(mcpPath);
+        if (existing?.mcpServers?.gitnexus) {
+            delete existing.mcpServers.gitnexus;
+            await writeJsonFile(mcpPath, existing);
+        }
+        return { success: true, message: 'MCP removed from ~/.codeium/windsurf/mcp_config.json' };
+    }
+    catch (err) {
+        return { success: false, message: `Failed: ${err.message}` };
+    }
+}
+async function removeSkills() {
+    const skillsDir = path.join(os.homedir(), '.codeium', 'windsurf', 'skills');
+    let removed = 0;
+    for (const name of HUB_SKILLS) {
+        try {
+            await fs.rm(path.join(skillsDir, name), { recursive: true, force: true });
+            removed++;
+        }
+        catch { /* already gone */ }
+    }
+    return removed;
+}
+export const windsurfEditor = {
+    id: 'windsurf',
+    name: 'Windsurf',
+    configure,
+    unconfigure,
+    installSkills,
+    removeSkills,
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * @gitnexus/connect — Enterprise Editor Setup
+ *
+ * Commands:
+ *   (default)     Register Hub MCP, write CLAUDE.md / AGENTS.md, install skills
+ *   disconnect    Remove all GitNexus config, skills, and project files
+ *   index         Trigger indexing for a GitHub repo on the Hub
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+/**
+ * @gitnexus/connect — Enterprise Editor Setup
+ *
+ * Commands:
+ *   (default)     Register Hub MCP, write CLAUDE.md / AGENTS.md, install skills
+ *   disconnect    Remove all GitNexus config, skills, and project files
+ *   index         Trigger indexing for a GitHub repo on the Hub
+ */
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { loadConfig, saveConfig, clearConfig } from './config.js';
+import { HubAPI } from './api.js';
+import { isGitRepo, getGitRemoteUrl, parseGitRemote, matchRepo } from './project.js';
+import { writeProjectContext, removeProjectContext } from './context.js';
+import { generateConnectContext } from './content.js';
+import { detectInstalledEditors } from './editors/detect.js';
+import { cursorEditor } from './editors/cursor.js';
+import { windsurfEditor } from './editors/windsurf.js';
+import { opencodeEditor } from './editors/opencode.js';
+import { claudeCodeEditor } from './editors/claude-code.js';
+const DEFAULT_HUB_URL = 'https://gitnexus-enterprise-production.up.railway.app';
+const EDITORS = {
+    'claude-code': claudeCodeEditor,
+    cursor: cursorEditor,
+    windsurf: windsurfEditor,
+    opencode: opencodeEditor,
+};
+const BANNER = [
+    ' ██████╗ ██╗████████╗███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗',
+    '██╔════╝ ██║╚══██╔══╝████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝',
+    '██║  ███╗██║   ██║   ██╔██╗ ██║█████╗   ╚███╔╝ ██║   ██║███████╗',
+    '██║   ██║██║   ██║   ██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║',
+    '╚██████╔╝██║   ██║   ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║',
+    ' ╚═════╝ ╚═╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝',
+];
+const ok = (msg) => console.log(`  ${pc.green('✔')} ${msg}`);
+const info = (msg) => console.log(`  ${pc.cyan('ℹ')} ${msg}`);
+const warn = (msg) => console.log(`  ${pc.yellow('⚠')} ${msg}`);
+const fail = (msg) => console.error(`  ${pc.red('✗')} ${msg}`);
+function printBanner() {
+    console.log('');
+    for (const line of BANNER) {
+        console.log(`   ${pc.cyan(line)}`);
+    }
+    console.log('');
+    console.log(`   ${pc.dim('Plug into the living brain of your codebase')}`);
+    console.log('');
+}
+/**
+ * Resolve token + Hub URL from args/config. Exits on failure.
+ */
+async function resolveAuth(tokenArg, hubOpt) {
+    const config = await loadConfig();
+    const token = tokenArg || config.hubToken;
+    const hubUrl = hubOpt || config.hubUrl || DEFAULT_HUB_URL;
+    if (!token) {
+        fail('No API token provided.');
+        console.error('');
+        console.error(`    Usage: ${pc.cyan('npx gitnexushub gnx_YOUR_TOKEN --editor cursor')}`);
+        console.error(`    Generate a token at: ${pc.cyan(hubUrl + '/settings/tokens')}`);
+        console.error('');
+        process.exit(1);
+    }
+    if (!token.startsWith('gnx_')) {
+        fail(`Invalid token format. Tokens must start with ${pc.bold('gnx_')}`);
+        console.error('');
+        process.exit(1);
+    }
+    const api = new HubAPI(hubUrl, token);
+    const user = await api.getMe().catch((err) => {
+        fail(`Authentication failed: ${err.message}`);
+        console.error(`    Check your token and try again.`);
+        console.error('');
+        process.exit(1);
+    });
+    ok(`Hello, ${pc.bold(user.name)}!`);
+    console.log('');
+    await saveConfig({ hubToken: token, hubUrl });
+    return { api, hubUrl, token };
+}
+// ─── CLI Setup ────────────────────────────────────────────────────
+const program = new Command();
+program
+    .name('gnx')
+    .description('Connect your editor to GitNexus Hub')
+    .version('0.2.0');
+// ─── Default command: connect ─────────────────────────────────────
+const connectOpts = (cmd) => cmd
+    .argument('[token]', 'gnx_ API token (optional if already saved)')
+    .option('--editor <name>', 'Editor to configure: claude-code | cursor | windsurf | opencode')
+    .option('--hub <url>', 'Hub URL', DEFAULT_HUB_URL)
+    .option('--skip-project', 'Only configure MCP, skip project files');
+const connectAction = async (tokenArg, opts) => {
+    try {
+        printBanner();
+        await runConnect(tokenArg, opts);
+    }
+    catch (err) {
+        console.error('');
+        fail(err.message);
+        console.error('');
+        process.exit(1);
+    }
+};
+// `gnx <token>` (default)
+connectOpts(program).action(connectAction);
+// `gnx connect <token>` (explicit)
+connectOpts(program.command('connect').description('Register Hub MCP, install skills, and write project files')).action(connectAction);
+// ─── disconnect command ───────────────────────────────────────────
+program
+    .command('disconnect')
+    .description('Remove GitNexus MCP config, skills, and project files')
+    .option('--editor <name>', 'Editor to unconfigure: claude-code | cursor | windsurf | opencode')
+    .action(async (opts) => {
+    try {
+        printBanner();
+        await runDisconnect(opts);
+    }
+    catch (err) {
+        console.error('');
+        fail(err.message);
+        console.error('');
+        process.exit(1);
+    }
+});
+// ─── index command ────────────────────────────────────────────────
+program
+    .command('index <repo>')
+    .description('Index a GitHub repo (owner/repo or URL)')
+    .option('--hub <url>', 'Hub URL', DEFAULT_HUB_URL)
+    .option('--token <token>', 'gnx_ API token (optional if already saved)')
+    .option('--wait', 'Wait for indexing to complete', false)
+    .action(async (repo, opts) => {
+    try {
+        printBanner();
+        await runIndex(repo, opts);
+    }
+    catch (err) {
+        console.error('');
+        fail(err.message);
+        console.error('');
+        process.exit(1);
+    }
+});
+program.parse();
+// ─── Connect Flow ─────────────────────────────────────────────────
+async function runConnect(tokenArg, opts) {
+    const { api, hubUrl, token } = await resolveAuth(tokenArg, opts.hub);
+    // ── Resolve editor ─────────────────────────────────────────────
+    const config = await loadConfig();
+    let editorId;
+    if (opts.editor) {
+        if (!(opts.editor in EDITORS)) {
+            fail(`Unknown editor: ${pc.bold(opts.editor)}`);
+            console.error(`    Supported: ${pc.cyan(Object.keys(EDITORS).join(', '))}`);
+            console.error('');
+            return process.exit(1);
+        }
+        editorId = opts.editor;
+    }
+    else if (!config.hubToken) {
+        const detected = await detectInstalledEditors();
+        if (detected.length === 1) {
+            editorId = detected[0];
+            info(`Auto-detected editor: ${pc.bold(EDITORS[editorId].name)}`);
+        }
+        else if (detected.length > 1) {
+            warn('Multiple editors detected. Please specify one:');
+            for (const id of detected) {
+                console.error(`      ${pc.cyan('--editor ' + id)}`);
+            }
+            console.error('');
+            return process.exit(1);
+        }
+        else {
+            fail('No editor detected. Please specify one:');
+            console.error(`      ${pc.cyan('--editor claude-code | cursor | windsurf | opencode')}`);
+            console.error('');
+            return process.exit(1);
+        }
+    }
+    // ── Configure editor MCP ────────────────────────────────────────
+    let skills = [];
+    if (editorId) {
+        const editor = EDITORS[editorId];
+        info(`Configuring ${pc.bold(editor.name)}...`);
+        const result = await editor.configure(hubUrl, token);
+        if (result.success) {
+            ok(result.message);
+        }
+        else {
+            fail(result.message);
+        }
+        try {
+            const bundled = await generateConnectContext('_', {});
+            skills = bundled.skills;
+        }
+        catch {
+            // Skills load failed — continue without
+        }
+        if (editor.installSkills && skills.length > 0) {
+            const count = await editor.installSkills(skills);
+            if (count > 0) {
+                ok(`${count} skills installed`);
+            }
+        }
+    }
+    // ── Write project context ───────────────────────────────────────
+    if (!opts.skipProject && isGitRepo()) {
+        const remoteUrl = getGitRemoteUrl();
+        const remoteFullName = remoteUrl ? parseGitRemote(remoteUrl) : null;
+        if (remoteFullName) {
+            console.log('');
+            info(`Project: ${pc.bold(remoteFullName)}`);
+            try {
+                const repos = await api.listRepos();
+                const matched = matchRepo(remoteFullName, repos);
+                if (matched) {
+                    if (matched.status === 'ready') {
+                        const ctx = await generateConnectContext(matched.fullName, matched.stats || {});
+                        const result = await writeProjectContext(process.cwd(), ctx);
+                        for (const file of result.files) {
+                            ok(file);
+                        }
+                    }
+                    else {
+                        warn(`Repo status: ${pc.yellow(matched.status)} ${pc.dim('(waiting for indexing)')}`);
+                    }
+                }
+                else {
+                    warn('Repo not indexed on Hub yet');
+                    console.log(`      Add it at: ${pc.cyan(hubUrl)}`);
+                }
+            }
+            catch (err) {
+                fail(`Failed to fetch project context: ${err.message}`);
+            }
+        }
+        else {
+            console.log('');
+            warn('No GitHub remote found — skipping project context');
+        }
+    }
+    else if (!opts.skipProject) {
+        console.log('');
+        info('Not inside a git repo — skipping project context');
+    }
+    // ── Summary ────────────────────────────────────────────────────
+    console.log('');
+    console.log(`  ${pc.green('✔')} ${pc.bold('Done!')} Open your editor — GitNexus MCP is ready.`);
+    console.log('');
+}
+// ─── Disconnect Flow ──────────────────────────────────────────────
+async function runDisconnect(opts) {
+    // ── Resolve which editors to clean ─────────────────────────────
+    let editorIds;
+    if (opts.editor) {
+        if (!(opts.editor in EDITORS)) {
+            fail(`Unknown editor: ${pc.bold(opts.editor)}`);
+            console.error(`    Supported: ${pc.cyan(Object.keys(EDITORS).join(', '))}`);
+            console.error('');
+            return process.exit(1);
+        }
+        editorIds = [opts.editor];
+    }
+    else {
+        // Clean all editors
+        editorIds = Object.keys(EDITORS);
+    }
+    // ── Remove MCP config and skills from each editor ──────────────
+    for (const id of editorIds) {
+        const editor = EDITORS[id];
+        const result = await editor.unconfigure();
+        if (result.success) {
+            ok(result.message);
+        }
+        else {
+            warn(`${editor.name}: ${result.message}`);
+        }
+        if (editor.removeSkills) {
+            const count = await editor.removeSkills();
+            if (count > 0) {
+                ok(`${count} skills removed from ${editor.name}`);
+            }
+        }
+    }
+    // ── Remove project-level files ─────────────────────────────────
+    if (isGitRepo()) {
+        const removed = await removeProjectContext(process.cwd());
+        for (const file of removed) {
+            ok(`Removed ${file}`);
+        }
+    }
+    // ── Clear saved config ─────────────────────────────────────────
+    await clearConfig();
+    ok('Cleared ~/.gitnexus/config.json');
+    console.log('');
+    console.log(`  ${pc.green('✔')} ${pc.bold('GitNexus fully disconnected.')}`);
+    console.log('');
+}
+// ─── Index Flow ───────────────────────────────────────────────────
+async function runIndex(repo, opts) {
+    const { api } = await resolveAuth(opts.token, opts.hub);
+    // Normalize: accept URLs or owner/repo
+    const fullName = repo
+        .replace(/^https?:\/\/github\.com\//, '')
+        .replace(/\.git\/?$/, '')
+        .replace(/\/+$/, '');
+    if (!fullName.includes('/')) {
+        fail(`Invalid repo format. Use ${pc.cyan('owner/repo')} or a GitHub URL.`);
+        console.error('');
+        process.exit(1);
+    }
+    info(`Indexing ${pc.bold(fullName)}...`);
+    let result;
+    try {
+        result = await api.indexRepo(fullName);
+        ok(`Repository added ${pc.dim(`(id: ${result.id})`)}`);
+        info(`Status: ${pc.yellow(result.status)}`);
+    }
+    catch (err) {
+        const msg = err.message || '';
+        // Already added — look it up instead of failing
+        if (msg.includes('already added')) {
+            const repos = await api.listRepos();
+            const existing = repos.find(r => r.fullName === fullName);
+            if (existing) {
+                if (existing.status === 'ready') {
+                    ok(`${pc.bold(fullName)} is already indexed and ready.`);
+                    const stats = existing.stats || {};
+                    ok(`${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} processes`);
+                    console.log('');
+                    console.log(`  ${pc.green('✔')} ${pc.bold('Done!')} Run ${pc.cyan('npx gitnexushub --editor claude-code')} to connect.`);
+                    console.log('');
+                    return;
+                }
+                info(`${pc.bold(fullName)} already added — status: ${pc.yellow(existing.status)}`);
+                result = { id: existing.id, status: existing.status };
+            }
+            else {
+                throw err;
+            }
+        }
+        else {
+            throw err;
+        }
+    }
+    if (!opts.wait) {
+        console.log('');
+        info(`Indexing started in the background.`);
+        console.log(`    Run ${pc.cyan(`npx gitnexushub index ${fullName} --wait`)} to follow progress.`);
+        console.log('');
+        return;
+    }
+    // ── Poll for completion ─────────────────────────────────────────
+    console.log('');
+    const repoId = result.id;
+    const spinFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frame = 0;
+    while (true) {
+        await new Promise(r => setTimeout(r, 2000));
+        try {
+            const detail = await api.getRepo(repoId);
+            const spinner = pc.cyan(spinFrames[frame % spinFrames.length]);
+            frame++;
+            if (detail.status === 'ready') {
+                const stats = detail.stats || {};
+                ok(`Indexing complete!`);
+                ok(`${pc.bold(fullName)}: ${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} processes`);
+                console.log('');
+                console.log(`  ${pc.green('✔')} ${pc.bold('Done!')} Run ${pc.cyan('npx gitnexushub --editor claude-code')} to connect.`);
+                console.log('');
+                return;
+            }
+            if (detail.status === 'failed') {
+                fail(`Indexing failed: ${detail.error || 'unknown error'}`);
+                console.error('');
+                process.exit(1);
+            }
+            // Show progress
+            const phase = detail.job?.phase || detail.status;
+            const progress = detail.job?.progress ?? 0;
+            const bar = renderProgressBar(progress);
+            process.stdout.write(`\r  ${spinner} ${pc.dim(phase)} ${bar} ${progress}%  `);
+        }
+        catch {
+            // Network hiccup — retry silently
+        }
+    }
+}
+function renderProgressBar(percent) {
+    const width = 20;
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return pc.green('█'.repeat(filled)) + pc.dim('░'.repeat(empty));
+}

package/dist/project.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Project Detection
+ *
+ * Detects git repos, parses remote URLs, and matches against Hub repos.
+ */
+import type { HubRepo } from './api.js';
+export declare function isGitRepo(): boolean;
+export declare function getGitRemoteUrl(): string | null;
+/**
+ * Parse owner/repo from a git remote URL.
+ *
+ * Supports:
+ *   https://github.com/owner/repo.git
+ *   git@github.com:owner/repo.git
+ *   https://github.com/owner/repo
+ */
+export declare function parseGitRemote(url: string): string | null;
+/**
+ * Match a local git remote against Hub repos.
+ */
+export declare function matchRepo(remoteFullName: string, hubRepos: HubRepo[]): HubRepo | null;

package/dist/project.js

@@ -0,0 +1,48 @@
+/**
+ * Project Detection
+ *
+ * Detects git repos, parses remote URLs, and matches against Hub repos.
+ */
+import { execSync } from 'child_process';
+export function isGitRepo() {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getGitRemoteUrl() {
+    try {
+        return execSync('git remote get-url origin', { stdio: 'pipe', encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse owner/repo from a git remote URL.
+ *
+ * Supports:
+ *   https://github.com/owner/repo.git
+ *   git@github.com:owner/repo.git
+ *   https://github.com/owner/repo
+ */
+export function parseGitRemote(url) {
+    // HTTPS format
+    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1];
+    // SSH format
+    const sshMatch = url.match(/github\.com:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1];
+    return null;
+}
+/**
+ * Match a local git remote against Hub repos.
+ */
+export function matchRepo(remoteFullName, hubRepos) {
+    return hubRepos.find(r => r.fullName === remoteFullName) || null;
+}