javi-forge 1.6.0 → 1.7.0

package/dist/lib/stack-detector.js

@@ -0,0 +1,207 @@
+import path from "node:path";
+import fs from "fs-extra";
+// ── Stack-to-Skills Mapping ────────────────────────────────────────────────
+/**
+ * Maps detected project signals to recommended AI skills.
+ * Each key is a detection signal (file/dependency/pattern),
+ * and the value is the list of skills it implies.
+ */
+export const SIGNAL_SKILL_MAP = {
+    // Frameworks
+    react: ["react-19"],
+    next: ["nextjs-15", "react-19"],
+    angular: [],
+    vue: [],
+    django: ["django-drf", "pytest"],
+    flask: ["pytest"],
+    fastapi: ["pytest"],
+    // Languages / runtimes
+    typescript: ["typescript"],
+    python: ["pytest"],
+    go: [],
+    rust: [],
+    elixir: [],
+    // Styling
+    tailwindcss: ["tailwind-4"],
+    // State management
+    zustand: ["zustand-5"],
+    // Validation
+    zod: ["zod-4"],
+    // AI SDKs
+    ai: ["ai-sdk-5"],
+    "@ai-sdk": ["ai-sdk-5"],
+    // Testing
+    vitest: [],
+    jest: [],
+    pytest: ["pytest"],
+    playwright: ["playwright"],
+};
+/**
+ * Additional file-based signals that don't come from package.json dependencies.
+ */
+const FILE_SIGNALS = [
+    {
+        files: ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"],
+        skills: ["tailwind-4"],
+    },
+    {
+        files: ["playwright.config.ts", "playwright.config.js"],
+        skills: ["playwright"],
+    },
+    { files: ["tsconfig.json"], skills: ["typescript"] },
+    {
+        files: ["pyproject.toml", "setup.py", "requirements.txt"],
+        skills: ["pytest"],
+    },
+    {
+        files: ["next.config.js", "next.config.mjs", "next.config.ts"],
+        skills: ["nextjs-15", "react-19"],
+    },
+];
+/**
+ * Docker-related files that indicate a containerized project.
+ * Used by the init command to suggest Docker zero-downtime deploy scaffolding.
+ */
+export const DOCKER_FILES = [
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+];
+/**
+ * Detect whether the project uses Docker (Dockerfile or compose file present).
+ */
+export async function detectDockerPresence(projectDir) {
+    for (const file of DOCKER_FILES) {
+        if (await fs.pathExists(path.join(projectDir, file))) {
+            return true;
+        }
+    }
+    return false;
+}
+// ── Core Detection ─────────────────────────────────────────────────────────
+/**
+ * Scan a project directory and detect its tech stack + recommended skills.
+ * Reads package.json deps, pyproject.toml, and well-known config files.
+ */
+export async function detectProjectStack(projectDir) {
+    const signals = [];
+    let stack = null;
+    // 1. Check Node.js (package.json)
+    const pkgPath = path.join(projectDir, "package.json");
+    if (await fs.pathExists(pkgPath)) {
+        stack = "node";
+        try {
+            const pkg = (await fs.readJson(pkgPath));
+            const allDeps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {}),
+            };
+            for (const depName of Object.keys(allDeps)) {
+                const normalizedDep = depName.replace(/^@/, "").split("/")[0];
+                for (const [signal, skills] of Object.entries(SIGNAL_SKILL_MAP)) {
+                    if (normalizedDep === signal ||
+                        depName === signal ||
+                        depName.startsWith(`@${signal}/`)) {
+                        if (skills.length > 0) {
+                            signals.push({ signal: depName, source: "package.json", skills });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* corrupt package.json — skip deps detection */
+        }
+    }
+    // 2. Check Python
+    const pythonFiles = ["pyproject.toml", "requirements.txt", "setup.py"];
+    for (const pyFile of pythonFiles) {
+        if (await fs.pathExists(path.join(projectDir, pyFile))) {
+            if (!stack)
+                stack = "python";
+            signals.push({
+                signal: pyFile,
+                source: "file exists",
+                skills: ["pytest"],
+            });
+            break;
+        }
+    }
+    // 3. Check Python deps from pyproject.toml
+    const pyprojectPath = path.join(projectDir, "pyproject.toml");
+    if (await fs.pathExists(pyprojectPath)) {
+        try {
+            const content = await fs.readFile(pyprojectPath, "utf-8");
+            if (/django/i.test(content)) {
+                signals.push({
+                    signal: "django",
+                    source: "pyproject.toml",
+                    skills: ["django-drf", "pytest"],
+                });
+            }
+            if (/fastapi/i.test(content)) {
+                signals.push({
+                    signal: "fastapi",
+                    source: "pyproject.toml",
+                    skills: ["pytest"],
+                });
+            }
+            if (/playwright/i.test(content)) {
+                signals.push({
+                    signal: "playwright",
+                    source: "pyproject.toml",
+                    skills: ["playwright"],
+                });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    // 4. Check Go
+    if (await fs.pathExists(path.join(projectDir, "go.mod"))) {
+        if (!stack)
+            stack = "go";
+    }
+    // 5. Check Rust
+    if (await fs.pathExists(path.join(projectDir, "Cargo.toml"))) {
+        if (!stack)
+            stack = "rust";
+    }
+    // 6. Check Elixir
+    if (await fs.pathExists(path.join(projectDir, "mix.exs"))) {
+        if (!stack)
+            stack = "elixir";
+    }
+    // 7. Check Java
+    if ((await fs.pathExists(path.join(projectDir, "build.gradle"))) ||
+        (await fs.pathExists(path.join(projectDir, "build.gradle.kts")))) {
+        if (!stack)
+            stack = "java-gradle";
+    }
+    if (await fs.pathExists(path.join(projectDir, "pom.xml"))) {
+        if (!stack)
+            stack = "java-maven";
+    }
+    // 8. File-based signals
+    for (const { files, skills } of FILE_SIGNALS) {
+        for (const file of files) {
+            if (await fs.pathExists(path.join(projectDir, file))) {
+                signals.push({ signal: file, source: "file exists", skills });
+                break; // Only need one file per signal group
+            }
+        }
+    }
+    // De-duplicate recommended skills
+    const skillSet = new Set();
+    for (const s of signals) {
+        for (const skill of s.skills) {
+            skillSet.add(skill);
+        }
+    }
+    const recommendedSkills = [...skillSet].sort();
+    return { stack, signals, recommendedSkills };
+}
+//# sourceMappingURL=stack-detector.js.map

package/dist/lib/supply-chain.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Supply chain protection — configures Socket Firewall and enforces
+ * minimum package release age to protect against typosquatting,
+ * dependency confusion, and malicious package takeovers.
+ */
+import type { Stack } from "../types/index.js";
+export type PackageManager = "npm" | "pnpm" | "yarn" | "pip" | "cargo" | "go";
+export interface SupplyChainConfig {
+    packageManager: PackageManager;
+    minReleaseAgeHours: number;
+    socketEnabled: boolean;
+    enforceLockfile: boolean;
+}
+export interface SupplyChainResult {
+    configWritten: string[];
+    warnings: string[];
+}
+export declare function detectPackageManager(projectDir: string): PackageManager;
+export declare function stackForPM(pm: PackageManager): Stack;
+export declare function buildSocketConfig(pm: PackageManager): Record<string, unknown>;
+export declare function buildNpmrcLines(minAgeHours: number): string[];
+export declare function configureSupplyChain(projectDir: string, options?: Partial<SupplyChainConfig>): Promise<SupplyChainResult>;
+//# sourceMappingURL=supply-chain.d.ts.map

package/dist/lib/supply-chain.js

@@ -0,0 +1,126 @@
+/**
+ * Supply chain protection — configures Socket Firewall and enforces
+ * minimum package release age to protect against typosquatting,
+ * dependency confusion, and malicious package takeovers.
+ */
+import path from "node:path";
+import fs from "fs-extra";
+// ── Detection ──
+export function detectPackageManager(projectDir) {
+    if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(projectDir, "yarn.lock")))
+        return "yarn";
+    if (fs.existsSync(path.join(projectDir, "package-lock.json")))
+        return "npm";
+    if (fs.existsSync(path.join(projectDir, "Pipfile.lock")))
+        return "pip";
+    if (fs.existsSync(path.join(projectDir, "Cargo.lock")))
+        return "cargo";
+    if (fs.existsSync(path.join(projectDir, "go.sum")))
+        return "go";
+    if (fs.existsSync(path.join(projectDir, "package.json")))
+        return "npm";
+    return "npm";
+}
+export function stackForPM(pm) {
+    switch (pm) {
+        case "npm":
+        case "pnpm":
+        case "yarn":
+            return "node";
+        case "pip":
+            return "python";
+        case "cargo":
+            return "rust";
+        case "go":
+            return "go";
+    }
+}
+// ── Socket Firewall config ──
+export function buildSocketConfig(pm) {
+    return {
+        version: 2,
+        projectType: stackForPM(pm),
+        issueRules: {
+            "pkg:npm/*": {
+                installScripts: "error",
+                telemetry: "warn",
+                troll: "error",
+                unpublished: "error",
+                deprecated: "warn",
+                unmaintained: "warn",
+                "new-author": "warn",
+                shellAccess: "error",
+                filesystemAccess: "warn",
+                networkAccess: "warn",
+                envAccess: "warn",
+            },
+        },
+    };
+}
+// ── npmrc / lockfile enforcement ──
+export function buildNpmrcLines(minAgeHours) {
+    const lines = [
+        "# Supply chain protection — generated by javi-forge",
+        "engine-strict=true",
+        "save-exact=true",
+    ];
+    if (minAgeHours > 0) {
+        lines.push(`# Minimum package age: ${minAgeHours}h (enforced via CI/pre-install hook)`);
+    }
+    return lines;
+}
+// ── Orchestrator ──
+export async function configureSupplyChain(projectDir, options = {}) {
+    const pm = options.packageManager ?? detectPackageManager(projectDir);
+    const minAge = options.minReleaseAgeHours ?? 48;
+    const socketEnabled = options.socketEnabled ?? true;
+    const enforceLockfile = options.enforceLockfile ?? true;
+    const configWritten = [];
+    const warnings = [];
+    // 1. Socket Firewall config
+    if (socketEnabled) {
+        const socketPath = path.join(projectDir, ".socketrc");
+        await fs.writeJson(socketPath, buildSocketConfig(pm), { spaces: 2 });
+        configWritten.push(".socketrc");
+    }
+    // 2. npmrc for node projects
+    if (stackForPM(pm) === "node") {
+        const npmrcPath = path.join(projectDir, ".npmrc");
+        const lines = buildNpmrcLines(minAge);
+        if (enforceLockfile) {
+            if (pm === "pnpm") {
+                lines.push("frozen-lockfile=true");
+            }
+            else {
+                lines.push("package-lock=true");
+            }
+        }
+        // Append to existing .npmrc if present
+        const existing = (await fs.pathExists(npmrcPath))
+            ? await fs.readFile(npmrcPath, "utf-8")
+            : "";
+        const newContent = existing
+            ? `${existing.trimEnd()}\n\n${lines.join("\n")}\n`
+            : `${lines.join("\n")}\n`;
+        await fs.writeFile(npmrcPath, newContent);
+        configWritten.push(".npmrc");
+    }
+    // 3. Supply chain metadata in baseline dir
+    const metaPath = path.join(projectDir, ".javi-forge", "supply-chain.json");
+    await fs.ensureDir(path.dirname(metaPath));
+    await fs.writeJson(metaPath, {
+        packageManager: pm,
+        minReleaseAgeHours: minAge,
+        socketEnabled,
+        enforceLockfile,
+        configuredAt: new Date().toISOString(),
+    }, { spaces: 2 });
+    configWritten.push(".javi-forge/supply-chain.json");
+    if (!socketEnabled) {
+        warnings.push("Socket Firewall disabled. Consider enabling it for supply chain protection.");
+    }
+    return { configWritten, warnings };
+}
+//# sourceMappingURL=supply-chain.js.map

package/dist/lib/team-presets.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agent Teams parallel dispatch presets — predefined team configurations
+ * for common workflows like review, debug, and security scanning.
+ *
+ * Each preset defines which sub-agents to spawn in parallel, their roles,
+ * and how to aggregate results.
+ */
+export interface AgentRole {
+    id: string;
+    name: string;
+    skill: string;
+    perspective: string;
+    priority: "critical" | "high" | "medium" | "low";
+}
+export interface TeamPreset {
+    name: string;
+    description: string;
+    roles: AgentRole[];
+    aggregation: "all-must-pass" | "majority" | "any-pass";
+    maxParallel: number;
+}
+export interface TeamDispatch {
+    preset: string;
+    roles: AgentRole[];
+    targetFiles: string[];
+    context: Record<string, string>;
+}
+export interface AgentResult {
+    roleId: string;
+    roleName: string;
+    passed: boolean;
+    findings: string[];
+    severity: "critical" | "high" | "medium" | "low" | "info";
+    durationMs: number;
+}
+export interface TeamResult {
+    preset: string;
+    passed: boolean;
+    agents: AgentResult[];
+    totalDurationMs: number;
+    summary: string;
+}
+export declare const TEAM_PRESETS: Record<string, TeamPreset>;
+export declare function getPreset(name: string): TeamPreset | null;
+export declare function listPresets(): Array<{
+    name: string;
+    description: string;
+    roleCount: number;
+}>;
+export declare function createDispatch(presetName: string, targetFiles: string[], context?: Record<string, string>): TeamDispatch | null;
+export declare function aggregateResults(preset: TeamPreset, results: AgentResult[]): TeamResult;
+export declare function formatTeamResult(result: TeamResult): string;
+//# sourceMappingURL=team-presets.d.ts.map

package/dist/lib/team-presets.js

@@ -0,0 +1,201 @@
+/**
+ * Agent Teams parallel dispatch presets — predefined team configurations
+ * for common workflows like review, debug, and security scanning.
+ *
+ * Each preset defines which sub-agents to spawn in parallel, their roles,
+ * and how to aggregate results.
+ */
+// ── Built-in presets ──
+export const TEAM_PRESETS = {
+    review: {
+        name: "review",
+        description: "Multi-perspective code review team",
+        roles: [
+            {
+                id: "quality",
+                name: "Quality Reviewer",
+                skill: "adversarial-review",
+                perspective: "code quality, readability, maintainability",
+                priority: "high",
+            },
+            {
+                id: "security",
+                name: "Security Auditor",
+                skill: "adversarial-review",
+                perspective: "security vulnerabilities, injection, auth",
+                priority: "critical",
+            },
+            {
+                id: "testing",
+                name: "Test Reviewer",
+                skill: "testing:test-coverage",
+                perspective: "test coverage, edge cases, test quality",
+                priority: "medium",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 3,
+    },
+    debug: {
+        name: "debug",
+        description: "Parallel debugging team",
+        roles: [
+            {
+                id: "hypothesis",
+                name: "Hypothesis Generator",
+                skill: "debug-mode",
+                perspective: "generate and rank failure hypotheses",
+                priority: "high",
+            },
+            {
+                id: "logs",
+                name: "Log Analyzer",
+                skill: "debug-mode",
+                perspective: "parse logs, stack traces, error patterns",
+                priority: "high",
+            },
+            {
+                id: "repro",
+                name: "Reproducer",
+                skill: "testing:e2e",
+                perspective: "create minimal reproduction steps",
+                priority: "medium",
+            },
+        ],
+        aggregation: "any-pass",
+        maxParallel: 3,
+    },
+    security: {
+        name: "security",
+        description: "Security scanning team",
+        roles: [
+            {
+                id: "sast",
+                name: "SAST Scanner",
+                skill: "adversarial-review",
+                perspective: "static analysis, code patterns, OWASP",
+                priority: "critical",
+            },
+            {
+                id: "deps",
+                name: "Dependency Auditor",
+                skill: "adversarial-review",
+                perspective: "supply chain, outdated deps, known CVEs",
+                priority: "critical",
+            },
+            {
+                id: "secrets",
+                name: "Secret Scanner",
+                skill: "adversarial-review",
+                perspective: "hardcoded secrets, API keys, credentials",
+                priority: "critical",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 3,
+    },
+    "tdd-cycle": {
+        name: "tdd-cycle",
+        description: "TDD pipeline team",
+        roles: [
+            {
+                id: "test-writer",
+                name: "Test Writer",
+                skill: "testing:tdd",
+                perspective: "write failing tests first",
+                priority: "high",
+            },
+            {
+                id: "implementer",
+                name: "Implementer",
+                skill: "sdd-apply",
+                perspective: "make tests pass with minimal code",
+                priority: "high",
+            },
+            {
+                id: "refactorer",
+                name: "Refactorer",
+                skill: "refactoring:cleanup",
+                perspective: "clean up without breaking tests",
+                priority: "medium",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 1, // sequential for TDD
+    },
+};
+// ── Preset management ──
+export function getPreset(name) {
+    return TEAM_PRESETS[name] ?? null;
+}
+export function listPresets() {
+    return Object.values(TEAM_PRESETS).map((p) => ({
+        name: p.name,
+        description: p.description,
+        roleCount: p.roles.length,
+    }));
+}
+// ── Dispatch creation ──
+export function createDispatch(presetName, targetFiles, context = {}) {
+    const preset = getPreset(presetName);
+    if (!preset)
+        return null;
+    return {
+        preset: presetName,
+        roles: preset.roles,
+        targetFiles,
+        context,
+    };
+}
+// ── Result aggregation ──
+export function aggregateResults(preset, results) {
+    const totalDurationMs = Math.max(...results.map((r) => r.durationMs), 0);
+    let passed;
+    switch (preset.aggregation) {
+        case "all-must-pass":
+            passed = results.every((r) => r.passed);
+            break;
+        case "majority":
+            passed = results.filter((r) => r.passed).length > results.length / 2;
+            break;
+        case "any-pass":
+            passed = results.some((r) => r.passed);
+            break;
+    }
+    const criticalFindings = results
+        .filter((r) => r.severity === "critical" && !r.passed)
+        .flatMap((r) => r.findings);
+    const summary = passed
+        ? `All ${results.length} agents passed.`
+        : `${results.filter((r) => !r.passed).length}/${results.length} agents reported issues.${criticalFindings.length > 0 ? ` ${criticalFindings.length} critical findings.` : ""}`;
+    return {
+        preset: preset.name,
+        passed,
+        agents: results,
+        totalDurationMs,
+        summary,
+    };
+}
+// ── Formatting ──
+export function formatTeamResult(result) {
+    const icon = result.passed ? "✅" : "❌";
+    const lines = [
+        `${icon} Team: ${result.preset} — ${result.summary}`,
+        "",
+    ];
+    for (const agent of result.agents) {
+        const aIcon = agent.passed ? "✓" : "✗";
+        const dur = `${(agent.durationMs / 1000).toFixed(1)}s`;
+        lines.push(`  ${aIcon} ${agent.roleName} [${agent.severity}] ${dur}`);
+        if (agent.findings.length > 0) {
+            for (const f of agent.findings.slice(0, 3)) {
+                lines.push(`    - ${f}`);
+            }
+            if (agent.findings.length > 3) {
+                lines.push(`    ... +${agent.findings.length - 3} more`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=team-presets.js.map

package/dist/lib/template.d.ts

@@ -1,4 +1,4 @@
-import type { Stack, CIProvider } from '../types/index.js';
+import type { CIProvider, Stack } from "../types/index.js";
 /**
  * Read a template file and replace __VAR_NAME__ placeholders.
  */
@@ -21,4 +21,19 @@ export declare function generateCIWorkflow(stack: Stack, provider: CIProvider):
  * Get the destination path for a CI workflow file within a project.
  */
 export declare function getCIDestination(provider: CIProvider): string;
+/**
+ * Get the template path for the zero-downtime Docker deploy workflow.
+ * Returns null if no template exists for the given provider.
+ */
+export declare function getDeployTemplatePath(provider: CIProvider): string | null;
+/**
+ * Get the destination path for the deploy workflow file within a project.
+ * Returns null if no mapping exists for the given provider.
+ */
+export declare function getDeployDestination(provider: CIProvider): string | null;
+/**
+ * Generate the zero-downtime Docker deploy workflow content.
+ * Replaces __SERVICE_NAME__ with the provided service name.
+ */
+export declare function generateDeployWorkflow(provider: CIProvider, serviceName: string): Promise<string | null>;
 //# sourceMappingURL=template.d.ts.map