flumli 0.0.1-alpha.1

package/dist/core/gh.js

@@ -0,0 +1,268 @@
+import { spawnSync } from 'node:child_process';
+/**
+ * Runs a gh command and returns a consistent result.
+ */
+function gh(args, cwd) {
+    const proc = spawnSync('gh', args, { encoding: 'utf-8', cwd });
+    return {
+        ok: proc.status === 0,
+        output: (proc.stdout ?? '').trim(),
+        error: (proc.stderr ?? '').trim(),
+    };
+}
+function git(args, cwd) {
+    const proc = spawnSync('git', args, { encoding: 'utf-8', cwd });
+    return {
+        ok: proc.status === 0,
+        output: (proc.stdout ?? '').trim(),
+        error: (proc.stderr ?? '').trim(),
+    };
+}
+/**
+ * Checks if the GitHub CLI is installed.
+ */
+export function isGhInstalled() {
+    return gh(['--version']).ok;
+}
+/**
+ * Checks if the user is authenticated with GitHub.
+ */
+export function isGhAuthenticated() {
+    return gh(['auth', 'status']).ok;
+}
+/**
+ * Returns owner/repo if inside a git repo with a GitHub remote, null otherwise.
+ */
+export function getRepoInfo() {
+    const { ok, output } = gh(['repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner']);
+    if (!ok)
+        return null;
+    const [owner, repo] = output.split('/');
+    if (owner && repo)
+        return { owner, repo };
+    return null;
+}
+/**
+ * Forks a repository on GitHub.
+ */
+export function forkRepository(owner, repo) {
+    const { ok, output, error } = gh([
+        'repo',
+        'fork',
+        `${owner}/${repo}`,
+        '--clone=false',
+        '--default-branch-only',
+    ]);
+    const combined = `${output}\n${error}`.trim();
+    const alreadyExists = combined.includes('already exists');
+    if (!ok && !alreadyExists) {
+        return { status: 'error', message: error || 'Fork failed' };
+    }
+    const match = combined.match(/[\w-]+\/[\w.-]+/);
+    if (match) {
+        const [forkOwner, forkRepo] = match[0].split('/');
+        return {
+            status: alreadyExists ? 'already_exists' : 'forked',
+            owner: forkOwner,
+            repo: forkRepo,
+        };
+    }
+    return { status: alreadyExists ? 'already_exists' : 'forked', owner, repo };
+}
+/**
+ * Clones a repo into the given directory.
+ */
+export function cloneRepo(owner, repo, dir) {
+    const target = dir ?? repo;
+    return gh(['repo', 'clone', `${owner}/${repo}`, target]);
+}
+/**
+ * Creates a new branch and switches to it.
+ */
+export function createBranch(name) {
+    const proc = spawnSync('git', ['checkout', '-b', name], { encoding: 'utf-8' });
+    return {
+        ok: proc.status === 0,
+        output: (proc.stdout ?? '').trim(),
+        error: (proc.stderr ?? '').trim(),
+    };
+}
+/**
+ * Pushes the current branch to the given remote (default: origin).
+ */
+export function pushBranch(remote = 'origin') {
+    const proc = spawnSync('git', ['push', '-u', remote, 'HEAD'], { encoding: 'utf-8' });
+    return {
+        ok: proc.status === 0,
+        output: (proc.stdout ?? '').trim(),
+        error: (proc.stderr ?? '').trim(),
+    };
+}
+/**
+ * Checks if the current branch has unpushed commits.
+ */
+export function hasUnpushedCommits() {
+    const proc = spawnSync('git', ['log', '--oneline', '@{u}..HEAD'], { encoding: 'utf-8' });
+    // If no upstream exists, everything is unpushed
+    if (proc.status !== 0)
+        return true;
+    return (proc.stdout ?? '').trim().length > 0;
+}
+/**
+ * Checks if a PR already exists for the current branch.
+ */
+export function prExists() {
+    const { ok, output } = gh(['pr', 'view', '--json', 'number', '-q', '.number']);
+    return ok && output.length > 0;
+}
+/**
+ * Returns the URL of the PR for the current branch, or null.
+ */
+export function getPrUrl() {
+    const { ok, output } = gh(['pr', 'view', '--json', 'url', '-q', '.url']);
+    return ok && output ? output : null;
+}
+/**
+ * Creates a draft PR against the upstream repo.
+ */
+export function createDraftPR(title, body) {
+    return gh(['pr', 'create', '--draft', '--title', title, '--body', body]);
+}
+/**
+ * Checks if the current branch has an upstream tracking branch.
+ */
+export function hasUpstream() {
+    const proc = spawnSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { encoding: 'utf-8' });
+    return proc.status === 0;
+}
+/**
+ * Returns the current branch name.
+ */
+export function getCurrentBranch() {
+    const proc = spawnSync('git', ['branch', '--show-current'], { encoding: 'utf-8' });
+    if (proc.status !== 0)
+        return null;
+    return (proc.stdout ?? '').trim() || null;
+}
+export function checkout(branch, expectedRepo, cwd) {
+    // Safety: verify we're in the right repo before touching anything
+    if (expectedRepo) {
+        const info = getRepoInfoAt(cwd);
+        if (!info) {
+            return { status: 'error', message: 'Not inside a git repository' };
+        }
+        const currentRepo = `${info.owner}/${info.repo}`;
+        if (currentRepo.toLowerCase() !== expectedRepo.toLowerCase()) {
+            return {
+                status: 'wrong_repo',
+                message: `Wrong repo: CLI is in ${currentRepo}, expected ${expectedRepo}`,
+                currentRepo,
+                expectedRepo,
+            };
+        }
+    }
+    const fetchResult = git(['fetch', 'origin'], cwd);
+    if (!fetchResult.ok) {
+        return { status: 'error', message: fetchResult.error || 'git fetch failed' };
+    }
+    const coResult = git(['checkout', branch], cwd);
+    if (!coResult.ok) {
+        // Branch might not exist locally yet — try checkout -b with tracking
+        const cobResult = git(['checkout', '-b', branch, `origin/${branch}`], cwd);
+        if (!cobResult.ok) {
+            return { status: 'error', message: cobResult.error || 'git checkout failed' };
+        }
+    }
+    return { status: 'ok', message: `Switched to ${branch}` };
+}
+/**
+ * Returns repo info for a specific directory (or cwd if not given).
+ */
+export function getRepoInfoAt(cwd) {
+    const { ok, output } = gh(['repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner'], cwd);
+    if (!ok)
+        return null;
+    const [owner, repo] = output.split('/');
+    if (owner && repo)
+        return { owner, repo };
+    return null;
+}
+/**
+ * Clones a repo and checks out a branch in the target directory.
+ */
+export function cloneAndCheckout(repo, branch, targetDir) {
+    const cloneResult = gh(['repo', 'clone', repo, targetDir]);
+    if (!cloneResult.ok) {
+        return { status: 'error', message: cloneResult.error || 'Clone failed' };
+    }
+    return checkout(branch, undefined, targetDir);
+}
+/**
+ * Gathers context about the current working state:
+ * repo, branch, linked issue, PR, push state.
+ */
+export function getWorkContext() {
+    const repoInfo = getRepoInfo();
+    const branch = getCurrentBranch();
+    if (!repoInfo || !branch)
+        return null;
+    const repo = `${repoInfo.owner}/${repoInfo.repo}`;
+    // Find PR for current branch
+    let pr = null;
+    const prResult = gh([
+        'pr',
+        'view',
+        '--json',
+        'number,title,url',
+        '-q',
+        '{number: .number, title: .title, url: .url}',
+    ]);
+    if (prResult.ok && prResult.output) {
+        try {
+            const parsed = JSON.parse(prResult.output);
+            if (parsed.number)
+                pr = parsed;
+        }
+        catch {
+            /* no PR */
+        }
+    }
+    // Find linked issue — extract from branch name (issue-123-...)
+    let issue = null;
+    const issueMatch = branch.match(/^issue-(\d+)/);
+    if (issueMatch) {
+        const issueNum = issueMatch[1];
+        const issueResult = gh([
+            'api',
+            `repos/${repo}/issues/${issueNum}`,
+            '--jq',
+            '{number: .number, title: .title}',
+        ]);
+        if (issueResult.ok && issueResult.output) {
+            try {
+                issue = JSON.parse(issueResult.output);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // Push state
+    const upstream = git(['rev-parse', '--abbrev-ref', '@{u}']).ok;
+    let pushState = 'nothing';
+    if (!upstream) {
+        pushState = 'first_push';
+    }
+    else {
+        const log = git(['log', '--oneline', '@{u}..HEAD']);
+        if (log.ok && log.output.length > 0)
+            pushState = 'has_commits';
+    }
+    return { repo, branch, issue, pr, pushState };
+}
+export function getLastCommitMessage() {
+    const proc = spawnSync('git', ['log', '-1', '--format=%s'], { encoding: 'utf-8' });
+    if (proc.status !== 0)
+        return null;
+    return (proc.stdout ?? '').trim() || null;
+}

package/dist/core/push.js

@@ -0,0 +1,60 @@
+import { hasUpstream, hasUnpushedCommits, pushBranch, prExists, getPrUrl, createDraftPR, getLastCommitMessage, } from "./gh.js";
+/**
+ * Generates a PR title suggestion from the branch name.
+ * e.g. "fix/login-bug" → "fix: login-bug"
+ *      "feat/add-auth" → "feat: add-auth"
+ *      "my-feature"    → "my-feature"
+ */
+export function suggestTitle(branch) {
+    const match = branch.match(/^(fix|feat|chore|docs|refactor|test|style|perf|ci|build)[/-](.+)/);
+    if (match)
+        return `${match[1]}: ${match[2]}`;
+    return branch;
+}
+/**
+ * Smart push: decides what to do based on the current git state.
+ *
+ * - No upstream → push + optionally create draft PR
+ * - Upstream + unpushed commits → push + optionally create draft PR
+ * - Upstream + no changes + no PR → optionally create draft PR
+ * - Everything done → nothing
+ */
+export function smartPush(opts) {
+    const upstream = hasUpstream();
+    const unpushed = upstream && hasUnpushedCommits();
+    // Push if needed
+    if (!upstream || unpushed) {
+        const push = pushBranch();
+        if (!push.ok) {
+            return { status: 'error', message: push.error || 'Push failed' };
+        }
+    }
+    // Create PR if title given and no PR exists yet
+    if (opts?.title && !prExists()) {
+        const body = opts.issueNumber ? `Closes #${opts.issueNumber}` : (getLastCommitMessage() ?? '');
+        const pr = createDraftPR(opts.title, body);
+        if (!pr.ok) {
+            return { status: 'error', message: pr.error || 'PR creation failed' };
+        }
+        if (!upstream || unpushed) {
+            return { status: 'pushed_with_pr', pr: pr.output };
+        }
+        return { status: 'created_pr', pr: pr.output };
+    }
+    if (!upstream || unpushed) {
+        return { status: 'pushed' };
+    }
+    return { status: 'nothing' };
+}
+/**
+ * Checks what action smartPush would take without executing it.
+ */
+export function checkPushState() {
+    const hasPr_ = prExists();
+    const prUrl = hasPr_ ? getPrUrl() : null;
+    if (!hasUpstream())
+        return { pushState: 'first_push', hasPr: false, prUrl: null };
+    if (hasUnpushedCommits())
+        return { pushState: 'has_commits', hasPr: hasPr_, prUrl };
+    return { pushState: 'nothing', hasPr: hasPr_, prUrl };
+}

package/dist/core/token.js

@@ -0,0 +1,13 @@
+import crypto from 'node:crypto';
+let _token = null;
+export function checkToken(token) {
+    return token === _token;
+}
+export function clearToken() {
+    _token = null;
+}
+export function generateToken() {
+    const token = crypto.randomBytes(16).toString('hex');
+    _token = token;
+    return token;
+}

package/dist/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import * as p from '@clack/prompts';
+import qrcode from 'qrcode-terminal';
+import { default as clipboard } from 'clipboardy';
+import { execSync } from 'node:child_process';
+import { isGhAuthenticated, isGhInstalled } from "./core/gh.js";
+import { startServer } from "./server.js";
+import { generateToken } from "./core/token.js";
+async function main() {
+    p.intro('flumli');
+    // Step 1: gh check
+    if (!isGhInstalled()) {
+        const install = await p.confirm({
+            message: 'gh (GitHub CLI) is not installed. Install now?',
+        });
+        if (install) {
+            const s = p.spinner();
+            s.start('Installing gh...');
+            try {
+                execSync('sudo apt install gh -y', { stdio: 'ignore' });
+                s.stop('gh installed.');
+            }
+            catch {
+                s.stop('Installation failed.');
+                p.log.error('Please install gh manually: https://cli.github.com');
+                process.exit(1);
+            }
+        }
+        else {
+            p.log.warn('flumli requires gh to function.');
+            process.exit(1);
+        }
+    }
+    // Step 2: gh auth check
+    if (!isGhAuthenticated()) {
+        p.log.info('You are not logged in to GitHub.');
+        const login = await p.confirm({
+            message: 'Log in with gh auth login now?',
+        });
+        if (login) {
+            try {
+                execSync('gh auth login', { stdio: 'inherit' });
+            }
+            catch {
+                p.log.error('Login failed.');
+                process.exit(1);
+            }
+        }
+        else {
+            p.log.warn('flumli requires a GitHub login.');
+            process.exit(1);
+        }
+    }
+    p.log.success('gh is ready.');
+    // Token + QR
+    const token = generateToken();
+    qrcode.generate('https://flumen.dev', { small: true });
+    p.note(token, 'Your token');
+    try {
+        clipboard.writeSync(token);
+        p.log.success('Token copied to clipboard.');
+    }
+    catch {
+        p.log.warn('Could not copy to clipboard.');
+    }
+    startServer();
+}
+main();

package/dist/server.js

@@ -0,0 +1,179 @@
+import * as p from '@clack/prompts';
+import { H3, handleCors, readBody, serve } from 'h3';
+import { checkToken } from "./core/token.js";
+import { checkPushState, smartPush } from "./core/push.js";
+import { checkout, cloneAndCheckout, getRepoInfoAt, getWorkContext } from "./core/gh.js";
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+let connected = false;
+const app = new H3()
+    .use((event) => {
+    const corsRes = handleCors(event, {
+        origin: '*',
+        methods: '*',
+        preflight: { statusCode: 204 },
+    });
+    if (corsRes !== false)
+        return corsRes;
+})
+    .get('/state', () => {
+    return { connected };
+})
+    .post('/connect', async (event) => {
+    const body = await readBody(event);
+    if (!body?.token || !checkToken(body.token)) {
+        p.log.warn('Connection attempt with invalid token.');
+        event.res.status = 401;
+        return { success: false, error: 'Invalid token' };
+    }
+    connected = true;
+    p.log.success('Flumen connected.');
+    showWorkContext();
+    return { success: true };
+})
+    .post('/disconnect', async () => {
+    connected = false;
+    p.log.info('Flumen disconnected.');
+    return { success: true };
+})
+    .get('/push', () => {
+    return checkPushState();
+})
+    .post('/push', async (event) => {
+    const body = await readBody(event);
+    const s = p.spinner();
+    s.start(body?.title ? `Pushing & creating PR: ${body.title}` : 'Pushing...');
+    const result = smartPush(body?.title ? { title: body.title, issueNumber: body.issueNumber } : undefined);
+    if (result.status === 'error') {
+        s.stop(`Push failed: ${result.message}`);
+        p.log.error(result.message);
+        event.res.status = 500;
+    }
+    else if (result.status === 'pushed_with_pr') {
+        s.stop('Pushed & PR created.');
+        p.log.success(`PR: ${result.pr}`);
+    }
+    else if (result.status === 'created_pr') {
+        s.stop('PR created.');
+        p.log.success(`PR: ${result.pr}`);
+    }
+    else if (result.status === 'pushed') {
+        s.stop('Pushed.');
+        p.log.success('Commits pushed to remote.');
+    }
+    else {
+        s.stop('Nothing to push.');
+        p.log.info('Everything up to date.');
+    }
+    showNextSteps();
+    return result;
+})
+    .post('/checkout', async (event) => {
+    const body = await readBody(event);
+    if (!body?.branch) {
+        p.log.error('Checkout requested without branch name.');
+        event.res.status = 400;
+        return { status: 'error', message: 'Missing branch name' };
+    }
+    p.log.step(`Checkout requested: ${body.branch}`);
+    if (body.repo) {
+        p.log.info(`Repository: ${body.repo}`);
+    }
+    const s = p.spinner();
+    s.start('Fetching & checking out...');
+    const result = checkout(body.branch, body.repo);
+    if (result.status === 'wrong_repo') {
+        s.stop('Wrong repository.');
+        p.log.warn(result.message);
+        // Respond immediately — handle interactively after
+        handleWrongRepo(body.branch, result.expectedRepo);
+        return { status: 'ok', message: 'Handling in CLI — check your terminal' };
+    }
+    if (result.status === 'error') {
+        s.stop('Checkout failed.');
+        p.log.error(result.message);
+        showNextSteps();
+        return result;
+    }
+    s.stop(`On branch ${body.branch}`);
+    p.log.success(result.message);
+    showWorkContext();
+    showNextSteps();
+    return result;
+});
+async function handleWrongRepo(branch, repo) {
+    const repoName = repo.split('/')[1] ?? repo;
+    const pathInput = await p.text({
+        message: `Where is ${repo}? Enter path to the repo, or a parent directory to clone into:`,
+        placeholder: `~/projects/${repoName}`,
+    });
+    if (p.isCancel(pathInput) || !pathInput.trim()) {
+        p.log.info('Skipped.');
+        showNextSteps();
+        return;
+    }
+    let targetDir = resolve(pathInput.trim().replace(/^~/, process.env.HOME ?? '~'));
+    if (!existsSync(targetDir)) {
+        p.log.error(`Path does not exist: ${targetDir}`);
+        showNextSteps();
+        return;
+    }
+    // Check if path points to the right repo
+    const info = getRepoInfoAt(targetDir);
+    if (info && `${info.owner}/${info.repo}`.toLowerCase() === repo.toLowerCase()) {
+        // Right repo — just checkout
+        const s = p.spinner();
+        s.start('Fetching & checking out...');
+        const result = checkout(branch, undefined, targetDir);
+        if (result.status === 'error') {
+            s.stop('Checkout failed.');
+            p.log.error(result.message);
+            showNextSteps();
+            return;
+        }
+        s.stop(`On branch ${branch}`);
+    }
+    else {
+        // Not the repo — clone into this directory
+        targetDir = resolve(targetDir, repoName);
+        const s = p.spinner();
+        s.start(`Cloning ${repo} into ${targetDir}...`);
+        const result = cloneAndCheckout(repo, branch, targetDir);
+        if (result.status === 'error') {
+            s.stop('Clone failed.');
+            p.log.error(result.message);
+            showNextSteps();
+            return;
+        }
+        s.stop('Cloned & checked out.');
+    }
+    p.log.success(`Ready at ${targetDir}`);
+    p.note(`cd ${targetDir}\n\nThen start flumli there to continue.`, 'Next steps');
+}
+function showWorkContext() {
+    const ctx = getWorkContext();
+    if (!ctx) {
+        p.note('Not inside a git repository.', 'Status');
+        return;
+    }
+    const lines = [`Repository:  ${ctx.repo}`, `Branch:      ${ctx.branch}`];
+    if (ctx.issue) {
+        lines.push(`Issue:       #${ctx.issue.number} ${ctx.issue.title}`);
+    }
+    if (ctx.pr) {
+        lines.push(`PR:          #${ctx.pr.number} ${ctx.pr.title}`);
+    }
+    if (ctx.pushState === 'first_push') {
+        lines.push('', 'Branch not yet pushed to remote.');
+    }
+    else if (ctx.pushState === 'has_commits') {
+        lines.push('', 'You have unpushed commits.');
+    }
+    p.note(lines.join('\n'), 'Status');
+}
+function showNextSteps() {
+    p.note('Waiting for commands from Flumen...\n\nCtrl+C to quit', 'Ready');
+}
+export function startServer(port = 31420) {
+    return serve(app, { port, silent: true });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "flumli",
+  "version": "0.0.1-alpha.1",
+  "description": "",
+  "keywords": [],
+  "license": "ISC",
+  "author": "",
+  "bin": {
+    "flumli": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "citty": "^0.2.1",
+    "clipboardy": "^5.3.0",
+    "h3": "2.0.1-rc.14",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.13",
+    "@types/qrcode-terminal": "^0.12.2"
+  },
+  "scripts": {
+    "dev": "node --watch src/index.ts",
+    "build": "pnpm exec tsc -p tsconfig.build.json",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}