javi-forge 1.1.0 → 1.3.0

package/dist/commands/ci.js

@@ -0,0 +1,341 @@
+import { execFile, spawn } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import { isDockerAvailable, ensureImage, runInContainer, openShell } from '../lib/docker.js';
+const execFileAsync = promisify(execFile);
+// =============================================================================
+// Stack detection
+// =============================================================================
+export async function detectCIStack(projectDir) {
+    let stackType = 'node';
+    let buildTool = 'npm';
+    let javaVersion = '21';
+    // Java Gradle
+    if (await fs.pathExists(path.join(projectDir, 'build.gradle.kts')) ||
+        await fs.pathExists(path.join(projectDir, 'build.gradle'))) {
+        stackType = 'java-gradle';
+        buildTool = 'gradle';
+        // Try to read java version from build files
+        const ktsPath = path.join(projectDir, 'build.gradle.kts');
+        const gradlePath = path.join(projectDir, 'build.gradle');
+        if (await fs.pathExists(ktsPath)) {
+            const content = await fs.readFile(ktsPath, 'utf-8');
+            const match = content.match(/JavaLanguageVersion\.of\((\d+)\)/);
+            if (match?.[1])
+                javaVersion = match[1];
+        }
+        else if (await fs.pathExists(gradlePath)) {
+            const content = await fs.readFile(gradlePath, 'utf-8');
+            const match = content.match(/sourceCompatibility\s*=\s*['"]*(\d+)/);
+            if (match?.[1])
+                javaVersion = match[1];
+        }
+    }
+    // Java Maven
+    else if (await fs.pathExists(path.join(projectDir, 'pom.xml'))) {
+        stackType = 'java-maven';
+        buildTool = 'mvn';
+    }
+    // Node
+    else if (await fs.pathExists(path.join(projectDir, 'package.json'))) {
+        stackType = 'node';
+        if (await fs.pathExists(path.join(projectDir, 'pnpm-lock.yaml')))
+            buildTool = 'pnpm';
+        else if (await fs.pathExists(path.join(projectDir, 'yarn.lock')))
+            buildTool = 'yarn';
+        else
+            buildTool = 'npm';
+    }
+    // Go
+    else if (await fs.pathExists(path.join(projectDir, 'go.mod'))) {
+        stackType = 'go';
+        buildTool = 'go';
+    }
+    // Rust
+    else if (await fs.pathExists(path.join(projectDir, 'Cargo.toml'))) {
+        stackType = 'rust';
+        buildTool = 'cargo';
+    }
+    // Python
+    else if (await fs.pathExists(path.join(projectDir, 'pyproject.toml')) ||
+        await fs.pathExists(path.join(projectDir, 'requirements.txt')) ||
+        await fs.pathExists(path.join(projectDir, 'setup.py'))) {
+        stackType = 'python';
+        if (await fs.pathExists(path.join(projectDir, 'uv.lock')))
+            buildTool = 'uv';
+        else if (await fs.pathExists(path.join(projectDir, 'poetry.lock')))
+            buildTool = 'poetry';
+        else
+            buildTool = 'pip';
+    }
+    // Build CI commands per stack
+    const { lintCmd, compileCmd, testCmd } = await buildCICommands(stackType, buildTool, projectDir);
+    return { stackType, buildTool, javaVersion, lintCmd, compileCmd, testCmd };
+}
+async function buildCICommands(stack, buildTool, projectDir) {
+    switch (stack) {
+        case 'java-gradle':
+            return {
+                lintCmd: './gradlew spotlessCheck --no-daemon',
+                compileCmd: './gradlew classes testClasses --no-daemon',
+                testCmd: './gradlew test --no-daemon',
+            };
+        case 'java-maven':
+            return {
+                lintCmd: './mvnw spotless:check',
+                compileCmd: './mvnw compile test-compile',
+                testCmd: './mvnw test',
+            };
+        case 'node': {
+            const pkgPath = path.join(projectDir, 'package.json');
+            let pkgContent = '';
+            try {
+                pkgContent = await fs.readFile(pkgPath, 'utf-8');
+            }
+            catch { /* no package.json */ }
+            // Clean dist/ before build to avoid permission issues from prior Docker builds
+            const buildPrefix = 'rm -rf dist/ && ';
+            return {
+                lintCmd: pkgContent.includes('"lint"') ? `${buildTool} run lint` : null,
+                compileCmd: pkgContent.includes('"build"') ? `${buildPrefix}${buildTool} run build` : null,
+                testCmd: pkgContent.includes('"test"') ? `${buildTool} ${buildTool === 'npm' ? 'test' : 'run test'}` : null,
+            };
+        }
+        case 'python':
+            return {
+                lintCmd: 'ruff check . && { pylint **/*.py 2>/dev/null || true; }',
+                compileCmd: null,
+                testCmd: 'pytest',
+            };
+        case 'go':
+            return {
+                lintCmd: 'golangci-lint run',
+                compileCmd: 'go build ./...',
+                testCmd: 'go test ./...',
+            };
+        case 'rust':
+            return {
+                lintCmd: 'cargo clippy -- -D warnings',
+                compileCmd: 'cargo build',
+                testCmd: 'cargo test',
+            };
+        default:
+            return { lintCmd: null, compileCmd: null, testCmd: null };
+    }
+}
+// =============================================================================
+// GHAGGA check
+// =============================================================================
+async function isGhaggaAvailable() {
+    try {
+        await execFileAsync('ghagga', ['--version'], { timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// =============================================================================
+// Main CI runner
+// =============================================================================
+function report(onStep, id, label, status, detail) {
+    onStep({ id, label, status, detail });
+}
+export async function runCI(options, onStep) {
+    const { projectDir = process.cwd(), mode = 'full', noDocker = false, noGhagga = false, noSecurity = false, timeout = 600, } = options;
+    // ── Detect stack ────────────────────────────────────────────────────────────
+    const stepDetect = 'detect';
+    report(onStep, stepDetect, 'Detecting stack', 'running');
+    let stackInfo;
+    try {
+        stackInfo = await detectCIStack(projectDir);
+        report(onStep, stepDetect, `Stack: ${stackInfo.stackType} (${stackInfo.buildTool})`, 'done');
+    }
+    catch (e) {
+        report(onStep, stepDetect, 'Detecting stack', 'error', String(e));
+        throw e;
+    }
+    // ── Detect mode ─────────────────────────────────────────────────────────────
+    if (mode === 'detect')
+        return;
+    // ── Shell mode ──────────────────────────────────────────────────────────────
+    if (mode === 'shell') {
+        if (noDocker) {
+            report(onStep, 'shell', 'Shell', 'error', '--shell requires Docker');
+            throw new Error('--shell requires Docker');
+        }
+        report(onStep, 'docker-image', 'Building Docker image', 'running');
+        try {
+            await ensureImage({ stack: stackInfo.stackType, javaVersion: stackInfo.javaVersion });
+            report(onStep, 'docker-image', 'Docker image ready', 'done');
+        }
+        catch (e) {
+            report(onStep, 'docker-image', 'Building Docker image', 'error', String(e));
+            throw e;
+        }
+        await openShell(projectDir);
+        return;
+    }
+    // ── Check Docker ─────────────────────────────────────────────────────────────
+    if (!noDocker) {
+        const stepDocker = 'docker-check';
+        report(onStep, stepDocker, 'Checking Docker', 'running');
+        const dockerOk = await isDockerAvailable();
+        if (!dockerOk) {
+            report(onStep, stepDocker, 'Docker not available', 'error', 'Start Docker or use --no-docker');
+            throw new Error('Docker is not available');
+        }
+        report(onStep, stepDocker, 'Docker available', 'done');
+        // Build image
+        const stepImage = 'docker-image';
+        report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, 'running');
+        try {
+            await ensureImage({ stack: stackInfo.stackType, javaVersion: stackInfo.javaVersion });
+            report(onStep, stepImage, 'Docker image ready', 'done');
+        }
+        catch (e) {
+            report(onStep, stepImage, 'Building Docker image', 'error', String(e));
+            throw e;
+        }
+    }
+    // ── Lint ─────────────────────────────────────────────────────────────────────
+    if (stackInfo.lintCmd) {
+        const stepLint = 'lint';
+        report(onStep, stepLint, `Lint: ${stackInfo.lintCmd}`, 'running');
+        try {
+            await runStep(stackInfo.lintCmd, projectDir, noDocker, timeout);
+            report(onStep, stepLint, 'Lint passed', 'done');
+        }
+        catch (e) {
+            report(onStep, stepLint, 'Lint failed', 'error', String(e));
+            throw e;
+        }
+    }
+    // ── Compile ──────────────────────────────────────────────────────────────────
+    if (stackInfo.compileCmd) {
+        const stepCompile = 'compile';
+        report(onStep, stepCompile, `Compile: ${stackInfo.compileCmd}`, 'running');
+        try {
+            await runStep(stackInfo.compileCmd, projectDir, noDocker, timeout);
+            report(onStep, stepCompile, 'Compile passed', 'done');
+        }
+        catch (e) {
+            report(onStep, stepCompile, 'Compile failed', 'error', String(e));
+            throw e;
+        }
+    }
+    // ── Test (full mode only) ────────────────────────────────────────────────────
+    if (mode === 'full' && stackInfo.testCmd) {
+        const stepTest = 'test';
+        report(onStep, stepTest, `Test: ${stackInfo.testCmd}`, 'running');
+        try {
+            await runStep(stackInfo.testCmd, projectDir, noDocker, timeout);
+            report(onStep, stepTest, 'Tests passed', 'done');
+        }
+        catch (e) {
+            report(onStep, stepTest, 'Tests failed', 'error', String(e));
+            throw e;
+        }
+    }
+    // ── Security scan (full mode only) ──────────────────────────────────────────
+    if (mode === 'full' && !noSecurity) {
+        const stepSecurity = 'security';
+        const semgrepAvailable = await isSemgrepAvailable();
+        if (semgrepAvailable) {
+            report(onStep, stepSecurity, 'Security scan (Semgrep)', 'running');
+            try {
+                await runSemgrep(projectDir);
+                report(onStep, stepSecurity, 'Security scan passed', 'done');
+            }
+            catch (e) {
+                report(onStep, stepSecurity, 'Security scan failed', 'error', String(e));
+                throw e;
+            }
+        }
+        else {
+            report(onStep, stepSecurity, 'Security scan', 'skipped', 'Semgrep not available — install semgrep or Docker');
+        }
+    }
+    // ── GHAGGA review (full mode only) ──────────────────────────────────────────
+    if (mode === 'full' && !noGhagga) {
+        const stepGhagga = 'ghagga';
+        const ghagga = await isGhaggaAvailable();
+        if (ghagga) {
+            report(onStep, stepGhagga, 'GHAGGA review', 'running');
+            try {
+                await runGhagga(projectDir);
+                report(onStep, stepGhagga, 'GHAGGA review passed', 'done');
+            }
+            catch (e) {
+                report(onStep, stepGhagga, 'GHAGGA review failed', 'error', String(e));
+                throw e;
+            }
+        }
+        else {
+            report(onStep, stepGhagga, 'GHAGGA review', 'skipped', 'ghagga not installed');
+        }
+    }
+}
+// =============================================================================
+// Step runners
+// =============================================================================
+async function runStep(command, projectDir, noDocker, timeout) {
+    if (noDocker) {
+        // Run natively
+        await new Promise((resolve, reject) => {
+            const proc = spawn('bash', ['-c', command], {
+                cwd: projectDir,
+                stdio: 'inherit',
+                env: { ...process.env, CI: 'true' },
+            });
+            proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Command failed with code ${code}`)));
+            proc.on('error', reject);
+        });
+    }
+    else {
+        const result = await runInContainer({
+            projectDir,
+            command: `cd /home/runner/work && ${command}`,
+            timeout,
+            stream: true,
+        });
+        if (result.exitCode !== 0) {
+            throw new Error(`Command failed with exit code ${result.exitCode}`);
+        }
+    }
+}
+async function isSemgrepAvailable() {
+    try {
+        await execFileAsync('semgrep', ['--version'], { timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runSemgrep(projectDir) {
+    // Look for semgrep config in project or use auto
+    const semgrepConfig = await fs.pathExists(path.join(projectDir, '.semgrep.yml'))
+        ? path.join(projectDir, '.semgrep.yml')
+        : 'auto';
+    await new Promise((resolve, reject) => {
+        const proc = spawn('semgrep', ['--config', semgrepConfig, '--severity', 'ERROR', '--quiet', '.'], {
+            cwd: projectDir,
+            stdio: 'inherit',
+        });
+        proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Semgrep found issues (exit ${code})`)));
+        proc.on('error', reject);
+    });
+}
+async function runGhagga(projectDir) {
+    await new Promise((resolve, reject) => {
+        const proc = spawn('ghagga', ['review', '--plain', '--exit-on-issues'], {
+            cwd: projectDir,
+            stdio: 'inherit',
+        });
+        proc.on('close', code => code === 0 ? resolve() : reject(new Error(`GHAGGA review found issues (exit ${code})`)));
+        proc.on('error', reject);
+    });
+}
+//# sourceMappingURL=ci.js.map

package/dist/commands/init.js

@@ -49,6 +49,11 @@ export async function initProject(options, onStep) {
                 // Set core.hooksPath to ci-local/hooks
                 const hooksDir = path.join(ciLocalDest, 'hooks');
                 if (await fs.pathExists(hooksDir)) {
+                    // Ensure hooks are executable
+                    const hookFiles = await fs.readdir(hooksDir);
+                    for (const hook of hookFiles) {
+                        await fs.chmod(path.join(hooksDir, hook), 0o755);
+                    }
                     await execFileAsync('git', ['config', 'core.hooksPath', 'ci-local/hooks'], { cwd: projectDir });
                 }
             }

package/dist/index.js

@@ -2,18 +2,26 @@
 import React from 'react';
 import { render } from 'ink';
 import meow from 'meow';
+import updateNotifier from 'update-notifier';
+import { createRequire } from 'module';
 import App from './ui/App.js';
 import Doctor from './ui/Doctor.js';
 import AnalyzeUI from './ui/AnalyzeUI.js';
 import Plugin from './ui/Plugin.js';
 import LlmsTxt from './ui/LlmsTxt.js';
+import CI from './ui/CI.js';
 import { CIProvider as CIContextProvider } from './ui/CIContext.js';
+// Check for updates in background (non-blocking, cached 24h)
+const _require = createRequire(import.meta.url);
+const pkg = _require('../package.json');
+updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 * 24 }).notify();
 const cli = meow(`
   Usage
     $ javi-forge [command] [options]
 
   Commands
     init              Bootstrap a new project (default)
+    ci                Run CI simulation (lint + compile + test + security + ghagga)
     analyze           Run repoforge skills analysis
     doctor            Show health report
     plugin add        Install a plugin from GitHub (org/repo)
@@ -35,19 +43,28 @@ const cli = meow(`
     --version       Show version
     --help          Show this help
 
+  CI options (javi-forge ci)
+    --quick         Lint + compile only (fast, for pre-commit)
+    --shell         Open interactive shell in CI container
+    --detect        Show detected stack and exit
+    --no-docker     Run commands natively (no Docker)
+    --no-ghagga     Skip GHAGGA review
+    --no-security   Skip Semgrep security scan
+    --timeout N     Per-step timeout in seconds (default: 600)
+
   Examples
     $ javi-forge
     $ javi-forge init --dry-run
     $ javi-forge init --stack node --ci github
-    $ javi-forge init --dry-run --project-name app --stack node --ci github --batch
+    $ javi-forge ci
+    $ javi-forge ci --quick
+    $ javi-forge ci --no-ghagga --no-security
+    $ javi-forge ci --no-docker
+    $ javi-forge ci --shell
     $ javi-forge analyze
-    $ javi-forge analyze --dry-run
     $ javi-forge doctor
     $ javi-forge plugin add mapbox/agent-skills
     $ javi-forge plugin list
-    $ javi-forge plugin search ai
-    $ javi-forge plugin validate ./my-plugin
-    $ javi-forge plugin remove my-plugin
 `, {
     importMeta: import.meta,
     flags: {
@@ -59,6 +76,14 @@ const cli = meow(`
         ghagga: { type: 'boolean', default: false },
         mock: { type: 'boolean', default: false },
         batch: { type: 'boolean', default: false },
+        // CI flags
+        quick: { type: 'boolean', default: false },
+        shell: { type: 'boolean', default: false },
+        detect: { type: 'boolean', default: false },
+        noDocker: { type: 'boolean', default: false },
+        noGhagga: { type: 'boolean', default: false },
+        noSecurity: { type: 'boolean', default: false },
+        timeout: { type: 'number', default: 600 },
     }
 });
 const subcommand = cli.input[0] ?? 'init';
@@ -67,6 +92,15 @@ const VALID_CI = ['github', 'gitlab', 'woodpecker'];
 const VALID_MEMORY = ['engram', 'obsidian-brain', 'memory-simple', 'none'];
 const isCI = cli.flags.batch || process.env['CI'] === '1' || process.env['CI'] === 'true';
 switch (subcommand) {
+    case 'ci': {
+        const ciMode = cli.flags.detect ? 'detect'
+            : cli.flags.shell ? 'shell'
+                : cli.flags.quick ? 'quick'
+                    : 'full';
+        render(React.createElement(CIContextProvider, { isCI: true },
+            React.createElement(CI, { projectDir: process.cwd(), mode: ciMode, noDocker: cli.flags.noDocker, noGhagga: cli.flags.noGhagga, noSecurity: cli.flags.noSecurity, timeout: cli.flags.timeout })));
+        break;
+    }
     case 'doctor': {
         render(React.createElement(CIContextProvider, { isCI: isCI },
             React.createElement(Doctor, null)));

package/dist/lib/docker.d.ts

@@ -0,0 +1,43 @@
+import type { Stack } from '../types/index.js';
+export interface DockerRunOptions {
+    /** Absolute path to mount as /home/runner/work */
+    projectDir: string;
+    /** Command to run inside the container */
+    command: string;
+    /** Timeout in seconds (default: 600) */
+    timeout?: number;
+    /** Stream output to stdout/stderr (default: true) */
+    stream?: boolean;
+}
+export interface DockerRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface DockerImageOptions {
+    stack: Stack;
+    /** Java version override (only for java-* stacks) */
+    javaVersion?: string;
+    /** Directory where Dockerfiles are stored (defaults to package-bundled dir) */
+    dockerfilesDir?: string;
+}
+export declare function getImageName(stack: Stack): string;
+export declare function getDockerfileContent(stack: Stack): string;
+export declare function isDockerAvailable(): Promise<boolean>;
+/**
+ * Ensure a CI Docker image exists and is up-to-date.
+ * Rebuilds only if the Dockerfile content has changed (hash-based staleness check).
+ * Returns the image name.
+ */
+export declare function ensureImage(options: DockerImageOptions): Promise<string>;
+/**
+ * Run a shell command inside the CI Docker container.
+ * Mounts projectDir as /home/runner/work.
+ * Streams output to process.stdout/stderr by default.
+ */
+export declare function runInContainer(options: DockerRunOptions): Promise<DockerRunResult>;
+/**
+ * Open an interactive shell inside the CI container.
+ */
+export declare function openShell(projectDir: string): Promise<void>;
+//# sourceMappingURL=docker.d.ts.map