argustack 0.1.0

package/dist/cli/init.js

@@ -0,0 +1,966 @@
+import { input, confirm, password, checkbox } from '@inquirer/prompts';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
+import { execSync, spawn } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import ora from 'ora';
+import { isWorkspace } from '../workspace/resolver.js';
+import { createEmptyConfig, addSource, writeConfig } from '../workspace/config.js';
+import { resolveServerPath } from './mcp-install.js';
+import { SOURCE_META, ALL_SOURCES } from '../core/types/index.js';
+const currentDir = fileURLToPath(new URL('.', import.meta.url));
+function getTemplatesDir() {
+    const templatesDir = resolve(currentDir, '..', '..', 'templates');
+    if (!existsSync(templatesDir)) {
+        throw new Error(`Templates directory not found: ${templatesDir}`);
+    }
+    return templatesDir;
+}
+/**
+ * Strip path, query, fragment from a Jira URL.
+ * User may paste full board URL like:
+ *   https://team.atlassian.net/jira/software/c/projects/PAP/boards/43?search=462
+ * We only need: https://team.atlassian.net
+ */
+function extractJiraBaseUrl(raw) {
+    try {
+        const url = new URL(raw.trim());
+        return `${url.protocol}//${url.host}`;
+    }
+    catch {
+        return raw.trim().replace(/\/+$/, '');
+    }
+}
+// ─── Jira connection test (shared between interactive and non-interactive) ───
+async function testJiraConnection(url, email, token) {
+    const { Version3Client } = await import('jira.js');
+    const client = new Version3Client({
+        host: url,
+        authentication: { basic: { email, apiToken: token } },
+    });
+    const result = await client.projects.searchProjects({ maxResults: 200 });
+    return result.values.map((p) => p.key);
+}
+// ─── Interactive source setup ────────────────────────────────────────────────
+async function setupJiraInteractive() {
+    console.log('');
+    console.log(chalk.bold('  Jira setup'));
+    console.log(chalk.dim('  Connect to your Jira instance.\n'));
+    const jiraUrlRaw = await input({
+        message: 'Jira URL:',
+        default: 'https://your-team.atlassian.net',
+        validate: (val) => {
+            if (!val.startsWith('https://')) {
+                return 'Must start with https://';
+            }
+            return true;
+        },
+    });
+    const jiraUrl = extractJiraBaseUrl(jiraUrlRaw);
+    const jiraEmail = await input({
+        message: 'Email:',
+        validate: (val) => {
+            if (!val.includes('@')) {
+                return 'Must be a valid email';
+            }
+            return true;
+        },
+    });
+    let jiraToken;
+    let availableProjects;
+    for (;;) {
+        jiraToken = await password({
+            message: 'API Token:',
+            mask: '*',
+            validate: (val) => {
+                if (!val.trim()) {
+                    return 'Token is required';
+                }
+                return true;
+            },
+        });
+        const spinner = ora('Testing Jira connection...').start();
+        try {
+            availableProjects = await testJiraConnection(jiraUrl, jiraEmail, jiraToken);
+        }
+        catch (err) {
+            spinner.fail('Connection failed');
+            console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim('  Check URL, email, token. Generate token:'));
+            console.log(chalk.dim('  https://id.atlassian.com/manage-profile/security/api-tokens'));
+            const retry = await confirm({ message: 'Try again?', default: true });
+            if (retry) {
+                continue;
+            }
+            const skip = await confirm({ message: 'Skip Jira for now?', default: false });
+            if (skip) {
+                return null;
+            }
+            return setupJiraInteractive();
+        }
+        if (availableProjects.length === 0) {
+            spinner.warn('Connected, but found 0 projects. Token may have limited permissions.');
+            console.log(chalk.yellow('  Your token works but has no project access.'));
+            console.log(chalk.dim('  This usually means the token was pasted incorrectly or has restricted scopes.'));
+            const retry = await confirm({ message: 'Re-enter token?', default: true });
+            if (retry) {
+                continue;
+            }
+        }
+        else {
+            spinner.succeed(`Connected! Found ${availableProjects.length} projects: ${availableProjects.join(', ')}`);
+        }
+        break;
+    }
+    const jiraProjects = await checkbox({
+        message: 'Select projects to pull:',
+        choices: availableProjects.map((key) => ({
+            value: key,
+            name: key,
+        })),
+    });
+    if (jiraProjects.length === 0) {
+        console.log(chalk.yellow('  No projects selected.'));
+        return null;
+    }
+    return { jiraUrl, jiraEmail, jiraToken, jiraProjects };
+}
+function gitCloneWithProgress(url, targetPath, spinner) {
+    return new Promise((res, rej) => {
+        const proc = spawn('git', ['clone', '--progress', url, targetPath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: process.env['HOME'],
+        });
+        const repoName = url.split('/').pop()?.replace(/\.git$/, '') ?? 'repo';
+        proc.stderr.on('data', (data) => {
+            const line = data.toString().trim();
+            const match = /(\w[\w\s]+?):\s+(\d+)%\s+\((\d+)\/(\d+)\)/.exec(line);
+            if (match) {
+                const [, phase, pct] = match;
+                spinner.text = `Cloning ${repoName}: ${phase?.trim()} ${pct}%`;
+            }
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                res();
+            }
+            else {
+                rej(new Error(`git clone exited with code ${String(code)}`));
+            }
+        });
+        proc.on('error', rej);
+    });
+}
+async function collectGitRepoLocal() {
+    const rawPath = await input({
+        message: 'Path to local repo:',
+        validate: (val) => {
+            const trimmed = val.trim();
+            if (!trimmed) {
+                return 'Path is required';
+            }
+            const resolved = resolve(trimmed.replace(/^~/, process.env['HOME'] ?? '~'));
+            if (!existsSync(join(resolved, '.git'))) {
+                return `Not a git repository: ${resolved} (no .git/ directory)`;
+            }
+            return true;
+        },
+    });
+    return resolve(rawPath.trim().replace(/^~/, process.env['HOME'] ?? '~'));
+}
+async function collectGitRepoGithub() {
+    const githubToken = await password({
+        message: 'GitHub token (PAT):',
+        mask: '*',
+        validate: (val) => {
+            if (!val.trim()) {
+                return 'Token is required';
+            }
+            return true;
+        },
+    });
+    const spinner = ora('Fetching accessible repositories...').start();
+    let repos;
+    try {
+        const { Octokit } = await import('octokit');
+        const octokit = new Octokit({ auth: githubToken.trim() });
+        const result = await octokit.rest.repos.listForAuthenticatedUser({
+            per_page: 100,
+            sort: 'updated',
+            direction: 'desc',
+        });
+        repos = result.data.map((r) => ({
+            full_name: r.full_name,
+            clone_url: r.clone_url,
+            isPrivate: r.private,
+            description: r.description,
+        }));
+        spinner.succeed(`Found ${repos.length} repositories`);
+    }
+    catch (err) {
+        spinner.fail('Failed to fetch repositories');
+        console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        return { paths: [], token: githubToken.trim(), repos: [] };
+    }
+    if (repos.length === 0) {
+        console.log(chalk.yellow('  No repositories accessible with this token.'));
+        return { paths: [], token: githubToken.trim(), repos: [] };
+    }
+    const selectedRepos = await checkbox({
+        message: 'Select repositories to clone:',
+        choices: repos.map((r) => ({
+            value: { cloneUrl: r.clone_url, fullName: r.full_name },
+            name: `${r.full_name} ${r.isPrivate ? '(private)' : '(public)'}`,
+            ...(r.description ? { description: r.description } : {}),
+        })),
+    });
+    if (selectedRepos.length === 0) {
+        console.log(chalk.yellow('  No repositories selected.'));
+        return { paths: [], token: githubToken.trim(), repos: [] };
+    }
+    const clonedPaths = [];
+    const clonedRepos = [];
+    for (const { cloneUrl, fullName } of selectedRepos) {
+        const repoName = cloneUrl.split('/').pop()?.replace(/\.git$/, '') ?? 'repo';
+        const defaultPath = resolve(repoName);
+        const cloneDir = await input({
+            message: `Clone ${repoName} into directory:`,
+            default: defaultPath,
+        });
+        const targetPath = resolve(cloneDir.trim().replace(/^~/, process.env['HOME'] ?? '~'));
+        const cloneSpinner = ora(`Cloning ${repoName}...`).start();
+        try {
+            await gitCloneWithProgress(cloneUrl, targetPath, cloneSpinner);
+            cloneSpinner.succeed(`Cloned to ${targetPath}`);
+            clonedPaths.push(targetPath);
+            clonedRepos.push(fullName);
+        }
+        catch (err) {
+            cloneSpinner.fail(`Failed to clone ${repoName}`);
+            console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+    return { paths: clonedPaths, token: githubToken.trim(), repos: clonedRepos };
+}
+async function collectGitRepoUrl() {
+    const repoUrl = await input({
+        message: 'Repository URL (HTTPS):',
+        validate: (val) => {
+            const trimmed = val.trim();
+            if (!trimmed) {
+                return 'URL is required';
+            }
+            if (!trimmed.startsWith('https://') && !trimmed.startsWith('git@')) {
+                return 'Must start with https:// or git@';
+            }
+            return true;
+        },
+    });
+    const defaultDir = repoUrl.trim().split('/').pop()?.replace(/\.git$/, '') ?? 'repo';
+    const defaultPath = resolve(defaultDir);
+    const cloneDir = await input({
+        message: 'Clone into directory:',
+        default: defaultPath,
+    });
+    const targetPath = resolve(cloneDir.trim().replace(/^~/, process.env['HOME'] ?? '~'));
+    const spinner = ora(`Cloning ${repoUrl.trim()}...`).start();
+    try {
+        await gitCloneWithProgress(repoUrl.trim(), targetPath, spinner);
+        spinner.succeed(`Cloned to ${targetPath}`);
+        return targetPath;
+    }
+    catch (err) {
+        spinner.fail('Clone failed');
+        console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        console.log(chalk.dim('  Check URL and network. Make sure git is installed.'));
+        return null;
+    }
+}
+async function setupGitInteractive() {
+    console.log('');
+    console.log(chalk.bold('  Git setup'));
+    console.log(chalk.dim('  Connect to Git repositories.\n'));
+    const { select } = await import('@inquirer/prompts');
+    const gitRepoPaths = [];
+    let savedGithubToken;
+    const savedGithubRepos = [];
+    let addMore = true;
+    while (addMore) {
+        const mode = await select({
+            message: gitRepoPaths.length === 0
+                ? 'Where is your Git repository?'
+                : 'Add another Git repository:',
+            choices: [
+                {
+                    value: 'local',
+                    name: 'Local path',
+                    description: 'The repo is already downloaded to your computer. ' +
+                        'You just point to the folder where it lives (e.g. ~/projects/my-app). ' +
+                        'Nothing is downloaded — Argustack reads commit history directly from disk',
+                },
+                {
+                    value: 'github',
+                    name: 'Clone from GitHub',
+                    description: 'You have a GitHub account with access to the repo. ' +
+                        'Enter your GitHub token — Argustack will show all repos you have access to, ' +
+                        'you pick the ones you need, and they download automatically',
+                },
+                {
+                    value: 'clone',
+                    name: 'Clone from URL',
+                    description: 'You have a direct link to the repo (from GitHub, GitLab, Bitbucket, or any git server). ' +
+                        'Paste the URL and Argustack will download the repo for you. ' +
+                        'Use this if your repo is not on GitHub or you prefer to paste the link manually',
+                },
+            ],
+        });
+        if (mode === 'local') {
+            const path = await collectGitRepoLocal();
+            if (path) {
+                gitRepoPaths.push(path);
+            }
+        }
+        else if (mode === 'github') {
+            const result = await collectGitRepoGithub();
+            gitRepoPaths.push(...result.paths);
+            savedGithubToken = result.token;
+            savedGithubRepos.push(...result.repos);
+        }
+        else {
+            const path = await collectGitRepoUrl();
+            if (path) {
+                gitRepoPaths.push(path);
+            }
+        }
+        if (gitRepoPaths.length === 0) {
+            const skip = await confirm({ message: 'Skip Git for now?', default: true });
+            if (skip) {
+                return null;
+            }
+            continue;
+        }
+        addMore = await confirm({ message: 'Add another Git repository?', default: false });
+    }
+    if (gitRepoPaths.length === 0) {
+        return null;
+    }
+    for (const p of gitRepoPaths) {
+        console.log(chalk.green(`  Git source configured: ${p}`));
+    }
+    return {
+        gitRepoPaths,
+        ...(savedGithubToken ? { githubToken: savedGithubToken } : {}),
+        ...(savedGithubRepos.length > 0 ? { githubRepos: savedGithubRepos } : {}),
+    };
+}
+async function setupGithubInteractive(existingToken, existingRepos) {
+    console.log('');
+    console.log(chalk.bold('  GitHub setup'));
+    console.log(chalk.dim('  Connect to GitHub API for PRs, reviews, and releases.\n'));
+    if (existingToken && existingRepos && existingRepos.length > 0) {
+        const repoToUse = existingRepos[0] ?? '';
+        const [owner = '', repo = ''] = repoToUse.split('/');
+        if (existingRepos.length === 1) {
+            console.log(chalk.green(`  Auto-configured from Git step: ${repoToUse}`));
+        }
+        else {
+            console.log(chalk.dim(`  Repos from Git step: ${existingRepos.join(', ')}`));
+            console.log(chalk.green(`  Using first repo for GitHub PRs: ${repoToUse}`));
+        }
+        return {
+            githubToken: existingToken.trim(),
+            githubOwner: owner,
+            githubRepo: repo,
+        };
+    }
+    let githubToken;
+    if (existingToken) {
+        console.log(chalk.green('  Using GitHub token from Git clone step.'));
+        githubToken = existingToken;
+    }
+    else {
+        console.log(chalk.dim('  Generate token: Settings → Developer settings → Personal access tokens'));
+        githubToken = await password({
+            message: 'GitHub token (PAT):',
+            mask: '*',
+            validate: (val) => {
+                if (!val.trim()) {
+                    return 'Token is required';
+                }
+                return true;
+            },
+        });
+    }
+    const spinner = ora('Fetching accessible repositories...').start();
+    let repos;
+    try {
+        const { Octokit } = await import('octokit');
+        const octokit = new Octokit({ auth: githubToken.trim() });
+        const result = await octokit.rest.repos.listForAuthenticatedUser({
+            per_page: 100,
+            sort: 'updated',
+            direction: 'desc',
+        });
+        repos = result.data.map((r) => ({
+            full_name: r.full_name,
+            isPrivate: r.private,
+            description: r.description,
+        }));
+        spinner.succeed(`Found ${repos.length} accessible repositories`);
+    }
+    catch (err) {
+        spinner.fail('Failed to fetch repositories');
+        console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        console.log(chalk.dim('  You can add GitHub token to .env later.'));
+        const skip = await confirm({ message: 'Skip GitHub for now?', default: true });
+        if (skip) {
+            return null;
+        }
+        return setupGithubInteractive(existingToken);
+    }
+    if (repos.length === 0) {
+        console.log(chalk.yellow('  No repositories accessible with this token.'));
+        console.log(chalk.dim('  Make sure the token has access to at least one repository.'));
+        return null;
+    }
+    const { select } = await import('@inquirer/prompts');
+    const selectedRepo = await select({
+        message: 'Select repository:',
+        choices: repos.map((r) => ({
+            value: r.full_name,
+            name: `${r.full_name} ${r.isPrivate ? '(private)' : '(public)'}`,
+            ...(r.description ? { description: r.description } : {}),
+        })),
+    });
+    const [owner = '', repo = ''] = selectedRepo.split('/');
+    console.log(chalk.green(`  GitHub configured: ${selectedRepo}`));
+    return {
+        githubToken: githubToken.trim(),
+        githubOwner: owner,
+        githubRepo: repo,
+    };
+}
+async function setupCsvInteractive() {
+    console.log('');
+    console.log(chalk.bold('  Jira CSV Import setup'));
+    console.log(chalk.dim('  Import issues from a Jira CSV export file.\n'));
+    const csvFilePath = await input({
+        message: 'Path to Jira CSV file:',
+        validate: (val) => {
+            if (!val.trim()) {
+                return 'CSV file path is required';
+            }
+            return true;
+        },
+    });
+    const resolved = resolve(csvFilePath.replace(/^~/, process.env['HOME'] ?? '~'));
+    console.log(chalk.green(`  CSV file: ${resolved}`));
+    return { csvFilePath: resolved };
+}
+async function setupDbInteractive() {
+    console.log('');
+    console.log(chalk.bold('  Database setup'));
+    console.log(chalk.dim('  Connect to the project database you want to analyze.\n'));
+    console.log(chalk.dim('  (This is the TARGET database, not Argustack internal DB)\n'));
+    const targetDbHost = await input({ message: 'DB Host:', default: 'localhost' });
+    const targetDbPortStr = await input({
+        message: 'DB Port:', default: '5432',
+        validate: (val) => {
+            const n = parseInt(val, 10);
+            if (isNaN(n) || n < 1 || n > 65535) {
+                return 'Port must be 1-65535';
+            }
+            return true;
+        },
+    });
+    const targetDbUser = await input({ message: 'DB User:' });
+    const targetDbPassword = await password({ message: 'DB Password:' });
+    const targetDbName = await input({ message: 'DB Name:' });
+    const targetDbPort = parseInt(targetDbPortStr, 10);
+    console.log(chalk.green(`  Database configured: ${targetDbUser}@${targetDbHost}:${targetDbPort}/${targetDbName}`));
+    return { targetDbHost, targetDbPort, targetDbUser, targetDbPassword, targetDbName };
+}
+// ─── Non-interactive source setup (from flags) ──────────────────────────────
+async function setupJiraFromFlags(flags) {
+    if (!flags.jiraUrl || !flags.jiraEmail || !flags.jiraToken) {
+        throw new Error('Jira requires: --jira-url, --jira-email, --jira-token');
+    }
+    const spinner = ora('Testing Jira connection...').start();
+    try {
+        const availableProjects = await testJiraConnection(extractJiraBaseUrl(flags.jiraUrl), flags.jiraEmail, flags.jiraToken);
+        spinner.succeed(`Connected! Found ${availableProjects.length} projects: ${availableProjects.join(', ')}`);
+        let jiraProjects;
+        if (!flags.jiraProjects || flags.jiraProjects.toLowerCase() === 'all') {
+            jiraProjects = availableProjects;
+        }
+        else {
+            jiraProjects = flags.jiraProjects.split(',').map((p) => p.trim().toUpperCase());
+        }
+        return {
+            jiraUrl: flags.jiraUrl,
+            jiraEmail: flags.jiraEmail,
+            jiraToken: flags.jiraToken,
+            jiraProjects,
+        };
+    }
+    catch (err) {
+        spinner.fail('Connection failed');
+        throw new Error(`Jira connection failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+function setupGitFromFlags(flags) {
+    if (!flags.gitRepo) {
+        throw new Error('Git requires: --git-repo');
+    }
+    const paths = flags.gitRepo.split(',').map((p) => p.trim()).filter(Boolean);
+    return { gitRepoPaths: paths };
+}
+function setupGithubFromFlags(flags) {
+    if (!flags.githubToken || !flags.githubOwner || !flags.githubRepo) {
+        throw new Error('GitHub requires: --github-token, --github-owner, --github-repo');
+    }
+    return {
+        githubToken: flags.githubToken,
+        githubOwner: flags.githubOwner,
+        githubRepo: flags.githubRepo,
+    };
+}
+function setupDbFromFlags(flags) {
+    if (!flags.targetDbHost || !flags.targetDbUser || !flags.targetDbName) {
+        throw new Error('Database requires: --target-db-host, --target-db-user, --target-db-name');
+    }
+    return {
+        targetDbHost: flags.targetDbHost,
+        targetDbPort: parseInt(flags.targetDbPort ?? '5432', 10),
+        targetDbUser: flags.targetDbUser,
+        targetDbPassword: flags.targetDbPassword ?? '',
+        targetDbName: flags.targetDbName,
+    };
+}
+function setupCsvFromFlags(flags) {
+    if (!flags.csvFile) {
+        throw new Error('CSV requires: --csv-file');
+    }
+    return { csvFilePath: flags.csvFile };
+}
+// ─── .env generation ─────────────────────────────────────────────────────────
+function generateEnv(jira, git, github, csv, db, argustackDbPort) {
+    const lines = [];
+    if (jira) {
+        lines.push('# === Jira ===', `JIRA_URL=${jira.jiraUrl}`, `JIRA_EMAIL=${jira.jiraEmail}`, `JIRA_API_TOKEN=${jira.jiraToken}`, `JIRA_PROJECTS=${jira.jiraProjects.join(',')}`, '');
+    }
+    if (git) {
+        lines.push('# === Git ===', `GIT_REPO_PATHS=${git.gitRepoPaths.join(',')}`, '');
+    }
+    if (github) {
+        lines.push('# === GitHub ===', `GITHUB_TOKEN=${github.githubToken}`, `GITHUB_OWNER=${github.githubOwner}`, `GITHUB_REPO=${github.githubRepo}`, '');
+    }
+    if (csv) {
+        lines.push('# === Jira CSV ===', `CSV_FILE_PATH=${csv.csvFilePath}`, '');
+    }
+    if (db) {
+        lines.push('# === Target Database (project DB to analyze) ===', `TARGET_DB_HOST=${db.targetDbHost}`, `TARGET_DB_PORT=${db.targetDbPort}`, `TARGET_DB_USER=${db.targetDbUser}`, `TARGET_DB_PASSWORD=${db.targetDbPassword}`, `TARGET_DB_NAME=${db.targetDbName}`, '');
+    }
+    lines.push('# === Argustack internal PostgreSQL (match docker-compose.yml) ===', 'DB_HOST=localhost', `DB_PORT=${argustackDbPort}`, 'DB_USER=argustack', 'DB_PASSWORD=argustack_local', 'DB_NAME=argustack', '', '# === OpenAI embeddings (optional, for semantic search) ===', '# OPENAI_API_KEY=sk-...');
+    return lines.join('\n') + '\n';
+}
+// ─── docker-compose generation ───────────────────────────────────────────────
+function generateDockerCompose(dbPort, pgwebPort) {
+    return `services:
+  db:
+    image: pgvector/pgvector:pg16
+    container_name: argustack-db
+    ports:
+      - "${dbPort}:5432"
+    environment:
+      POSTGRES_USER: argustack
+      POSTGRES_PASSWORD: argustack_local
+      POSTGRES_DB: argustack
+    volumes:
+      - argustack-data:/var/lib/postgresql/data
+      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U argustack"]
+      interval: 2s
+      timeout: 5s
+      retries: 15
+
+  pgweb:
+    image: sosedoff/pgweb
+    container_name: argustack-pgweb
+    ports:
+      - "${pgwebPort}:8081"
+    environment:
+      PGWEB_DATABASE_URL: postgres://argustack:argustack_local@db:5432/argustack?sslmode=disable
+    depends_on:
+      db:
+        condition: service_healthy
+    restart: on-failure
+
+volumes:
+  argustack-data:
+`;
+}
+// ─── Create workspace (shared logic) ─────────────────────────────────────────
+function createWorkspaceFiles(workspaceDir, jira, git, github, csv, db, dbPort, pgwebPort) {
+    const templatesDir = getTemplatesDir();
+    // Directories
+    mkdirSync(workspaceDir, { recursive: true });
+    mkdirSync(join(workspaceDir, '.argustack'), { recursive: true });
+    mkdirSync(join(workspaceDir, 'db'), { recursive: true });
+    mkdirSync(join(workspaceDir, 'data'), { recursive: true });
+    // Config
+    let config = createEmptyConfig();
+    if (jira) {
+        config = addSource(config, 'jira');
+    }
+    if (git) {
+        config = addSource(config, 'git');
+    }
+    if (github) {
+        config = addSource(config, 'github');
+    }
+    if (csv) {
+        config = addSource(config, 'csv');
+    }
+    if (db) {
+        config = addSource(config, 'db');
+    }
+    writeConfig(workspaceDir, config);
+    // .env
+    writeFileSync(join(workspaceDir, '.env'), generateEnv(jira, git, github, csv, db, dbPort));
+    // docker-compose.yml
+    writeFileSync(join(workspaceDir, 'docker-compose.yml'), generateDockerCompose(dbPort, pgwebPort));
+    // init.sql
+    copyFileSync(join(templatesDir, 'init.sql'), join(workspaceDir, 'db', 'init.sql'));
+    // .gitignore
+    copyFileSync(join(templatesDir, 'gitignore'), join(workspaceDir, '.gitignore'));
+    // .mcp.json — Claude Code auto-discovers MCP servers from this file
+    try {
+        const serverPath = resolveServerPath();
+        const mcpConfig = {
+            mcpServers: {
+                argustack: {
+                    command: 'node',
+                    args: [serverPath],
+                },
+            },
+        };
+        writeFileSync(join(workspaceDir, '.mcp.json'), JSON.stringify(mcpConfig, null, 2) + '\n');
+    }
+    catch {
+        // Server not built yet — skip .mcp.json, user can run `argustack mcp install` later
+    }
+}
+// ─── Summary output ──────────────────────────────────────────────────────────
+function printSummary(workspaceDir, jira, git, github, csv, db, pgwebPort, willAutoStart) {
+    console.log('');
+    console.log(chalk.green.bold('  Done! Your workspace is ready.'));
+    console.log('');
+    console.log(chalk.dim('  Sources configured:'));
+    if (jira) {
+        console.log(`    ${chalk.green('✓')} Jira — ${jira.jiraUrl}`);
+    }
+    if (git) {
+        for (const p of git.gitRepoPaths) {
+            console.log(`    ${chalk.green('✓')} Git — ${p}`);
+        }
+    }
+    if (github) {
+        console.log(`    ${chalk.green('✓')} GitHub — ${github.githubOwner}/${github.githubRepo}`);
+    }
+    if (csv) {
+        console.log(`    ${chalk.green('✓')} Jira CSV — ${csv.csvFilePath}`);
+    }
+    if (db) {
+        console.log(`    ${chalk.green('✓')} Database — ${db.targetDbHost}:${db.targetDbPort}`);
+    }
+    if (!jira && !git && !github && !csv && !db) {
+        console.log(`    ${chalk.yellow('—')} None yet. Use ${chalk.cyan('argustack source add <type>')}`);
+    }
+    if (!willAutoStart) {
+        console.log('');
+        console.log(chalk.dim('  Next steps:'));
+        console.log(`  ${chalk.cyan('cd')} ${workspaceDir}`);
+        console.log(`  ${chalk.cyan('docker compose up -d')}          # start database`);
+        if (jira) {
+            console.log(`  ${chalk.cyan('argustack sync jira')}            # sync from Jira`);
+        }
+        console.log(`  ${chalk.cyan(`http://localhost:${pgwebPort}`)}            # browse data in pgweb`);
+        console.log('');
+        console.log(chalk.dim('  Claude integration:'));
+        console.log(`    Claude Code:    ${chalk.green('Open this folder — MCP tools ready!')}`);
+        console.log(`    Claude Desktop: ${chalk.cyan('argustack mcp install')}`);
+    }
+    console.log('');
+}
+// ─── Non-interactive init ────────────────────────────────────────────────────
+async function runInitNonInteractive(flags) {
+    console.log(chalk.bold('\n  Argustack — non-interactive setup\n'));
+    // Workspace dir
+    const workspaceDir = resolve((flags.dir ?? process.cwd()).replace(/^~/, process.env['HOME'] ?? '~'));
+    // Parse sources
+    const selectedSources = flags.source
+        ? flags.source.split(',').map((s) => s.trim().toLowerCase())
+        : [];
+    // Validate source names
+    for (const s of selectedSources) {
+        if (!ALL_SOURCES.includes(s)) {
+            throw new Error(`Unknown source: ${s}. Available: ${ALL_SOURCES.join(', ')}`);
+        }
+    }
+    // Setup each source from flags
+    let jiraResult = null;
+    let gitResult = null;
+    let githubResult = null;
+    let csvResult = null;
+    let dbResult = null;
+    for (const source of selectedSources) {
+        switch (source) {
+            case 'jira':
+                jiraResult = await setupJiraFromFlags(flags);
+                break;
+            case 'git':
+                gitResult = setupGitFromFlags(flags);
+                break;
+            case 'github':
+                githubResult = setupGithubFromFlags(flags);
+                break;
+            case 'csv':
+                csvResult = setupCsvFromFlags(flags);
+                break;
+            case 'db':
+                dbResult = setupDbFromFlags(flags);
+                break;
+        }
+    }
+    const dbPort = parseInt(flags.dbPort ?? '5434', 10);
+    const pgwebPort = parseInt(flags.pgwebPort ?? '8086', 10);
+    // Create workspace
+    const spinner = ora('Creating workspace...').start();
+    try {
+        createWorkspaceFiles(workspaceDir, jiraResult, gitResult, githubResult, csvResult, dbResult, dbPort, pgwebPort);
+        spinner.succeed('Workspace created!');
+    }
+    catch (err) {
+        spinner.fail('Failed');
+        throw err;
+    }
+    printSummary(workspaceDir, jiraResult, gitResult, githubResult, csvResult, dbResult, pgwebPort, false);
+}
+// ─── Interactive init ────────────────────────────────────────────────────────
+async function runInitInteractive(flags) {
+    console.log('');
+    console.log(chalk.bold('  Argustack — workspace setup'));
+    console.log(chalk.dim('  Cross-reference Jira + Git + DB to analyze your project.\n'));
+    // 1. Where to create?
+    const targetDir = await input({
+        message: 'Workspace directory:',
+        default: flags.dir ?? process.cwd(),
+        validate: (val) => {
+            if (!val.trim()) {
+                return 'Directory path is required';
+            }
+            return true;
+        },
+    });
+    const workspaceDir = resolve(targetDir.replace(/^~/, process.env['HOME'] ?? '~'));
+    if (isWorkspace(workspaceDir)) {
+        console.log(chalk.yellow(`\n  Already an Argustack workspace: ${workspaceDir}`));
+        const proceed = await confirm({ message: 'Reinitialize this workspace?', default: false });
+        if (!proceed) {
+            console.log(chalk.dim('  Cancelled.'));
+            return;
+        }
+    }
+    // 2. Which sources?
+    console.log('');
+    const selectedSources = await checkbox({
+        message: 'Which sources do you have access to?',
+        choices: ALL_SOURCES.map((s) => ({
+            value: s,
+            name: SOURCE_META[s].label,
+            description: SOURCE_META[s].description,
+        })),
+    });
+    if (selectedSources.length === 0) {
+        console.log(chalk.yellow('\n  No sources selected. You can add them later with:'));
+        console.log(chalk.cyan('  argustack source add jira'));
+        console.log(chalk.cyan('  argustack source add git'));
+        console.log(chalk.cyan('  argustack source add github'));
+        console.log(chalk.cyan('  argustack source add db'));
+        const continueAnyway = await confirm({
+            message: 'Create workspace without sources?',
+            default: true,
+        });
+        if (!continueAnyway) {
+            console.log(chalk.dim('  Cancelled.'));
+            return;
+        }
+    }
+    // 3. Collect credentials for each selected source
+    let jiraResult = null;
+    let gitResult = null;
+    let githubResult = null;
+    let csvResult = null;
+    let dbResult = null;
+    for (const source of selectedSources) {
+        switch (source) {
+            case 'jira':
+                jiraResult = await setupJiraInteractive();
+                break;
+            case 'git':
+                gitResult = await setupGitInteractive();
+                break;
+            case 'github':
+                githubResult = await setupGithubInteractive(gitResult?.githubToken, gitResult?.githubRepos);
+                break;
+            case 'csv':
+                csvResult = await setupCsvInteractive();
+                break;
+            case 'db':
+                dbResult = await setupDbInteractive();
+                break;
+        }
+    }
+    // 4. Argustack internal DB ports
+    console.log('');
+    console.log(chalk.dim('  Argustack internal database (Docker):'));
+    const dbPortStr = await input({
+        message: 'PostgreSQL port:', default: flags.dbPort ?? '5434',
+        validate: (val) => {
+            const n = parseInt(val, 10);
+            if (isNaN(n) || n < 1024 || n > 65535) {
+                return 'Port must be 1024-65535';
+            }
+            return true;
+        },
+    });
+    const pgwebPortStr = await input({
+        message: 'pgweb UI port:', default: flags.pgwebPort ?? '8086',
+        validate: (val) => {
+            const n = parseInt(val, 10);
+            if (isNaN(n) || n < 1024 || n > 65535) {
+                return 'Port must be 1024-65535';
+            }
+            return true;
+        },
+    });
+    const dbPort = parseInt(dbPortStr, 10);
+    const pgwebPort = parseInt(pgwebPortStr, 10);
+    // 5. Create workspace
+    const spinner = ora('Creating workspace...').start();
+    try {
+        createWorkspaceFiles(workspaceDir, jiraResult, gitResult, githubResult, csvResult, dbResult, dbPort, pgwebPort);
+        spinner.succeed('Workspace created!');
+    }
+    catch (err) {
+        spinner.fail('Failed to create workspace');
+        console.log(chalk.red(`\n  Error: ${err instanceof Error ? err.message : String(err)}`));
+        return;
+    }
+    // 6. Offer to start DB + sync automatically
+    const autoStart = await confirm({
+        message: 'Start database and sync now?',
+        default: true,
+    });
+    printSummary(workspaceDir, jiraResult, gitResult, githubResult, csvResult, dbResult, pgwebPort, autoStart);
+    if (autoStart) {
+        await startAndSync(workspaceDir, jiraResult !== null, gitResult !== null, githubResult !== null, csvResult, pgwebPort);
+    }
+}
+async function startAndSync(workspaceDir, hasJira, hasGit, hasGithub, csv, pgwebPort) {
+    const spinnerDb = ora('Starting Docker containers...').start();
+    try {
+        execSync('docker compose up -d', { cwd: workspaceDir, stdio: 'pipe' });
+        spinnerDb.succeed('Database running!');
+    }
+    catch (err) {
+        spinnerDb.fail('Failed to start Docker');
+        console.log(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        console.log(chalk.dim('  Make sure Docker Desktop is running, then:'));
+        console.log(chalk.cyan(`  cd ${workspaceDir} && docker compose up -d`));
+        return;
+    }
+    // Wait for PostgreSQL to be ready
+    const spinnerWait = ora('Waiting for PostgreSQL...').start();
+    const maxWait = 30;
+    for (let i = 0; i < maxWait; i++) {
+        try {
+            execSync('docker compose exec -T db pg_isready -U argustack', { cwd: workspaceDir, stdio: 'pipe' });
+            spinnerWait.succeed('PostgreSQL ready!');
+            break;
+        }
+        catch {
+            if (i === maxWait - 1) {
+                spinnerWait.fail('PostgreSQL not ready after 30s');
+                console.log(chalk.dim('  Try manually: docker compose logs db'));
+                return;
+            }
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+    if (hasJira) {
+        console.log('');
+        try {
+            const { syncJiraFromInit } = await import('./sync.js');
+            await syncJiraFromInit(workspaceDir);
+        }
+        catch (err) {
+            console.log(chalk.red(`  Jira sync failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim(`  Try manually: cd ${workspaceDir} && argustack sync jira`));
+        }
+    }
+    if (hasGit) {
+        console.log('');
+        try {
+            const { syncGitFromInit } = await import('./sync.js');
+            await syncGitFromInit(workspaceDir);
+        }
+        catch (err) {
+            console.log(chalk.red(`  Git sync failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim(`  Try manually: cd ${workspaceDir} && argustack sync git`));
+        }
+    }
+    if (hasGithub) {
+        console.log('');
+        try {
+            const { syncGithubFromInit } = await import('./sync.js');
+            await syncGithubFromInit(workspaceDir);
+        }
+        catch (err) {
+            console.log(chalk.red(`  GitHub sync failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim(`  Try manually: cd ${workspaceDir} && argustack sync github`));
+        }
+    }
+    if (csv) {
+        console.log('');
+        try {
+            const { syncCsvFromInit } = await import('./sync.js');
+            await syncCsvFromInit(workspaceDir, csv.csvFilePath);
+        }
+        catch (err) {
+            console.log(chalk.red(`  CSV import failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim(`  Try manually: cd ${workspaceDir} && argustack sync csv`));
+        }
+    }
+    console.log(chalk.dim('  What\'s next:'));
+    console.log(`  ${chalk.cyan(`http://localhost:${pgwebPort}`)}            # browse data in pgweb`);
+    console.log('');
+    console.log(chalk.dim('  Claude integration:'));
+    console.log(`    Claude Code:    ${chalk.green('Open this folder — MCP tools ready!')}`);
+    console.log(`    Claude Desktop: ${chalk.cyan('argustack mcp install')}`);
+    console.log('');
+}
+// ─── Main entry point ────────────────────────────────────────────────────────
+export async function runInit(flags = {}) {
+    // --no-interactive sets flags.interactive to false
+    if (flags.interactive === false) {
+        await runInitNonInteractive(flags);
+    }
+    else {
+        await runInitInteractive(flags);
+    }
+}
+//# sourceMappingURL=init.js.map