archbyte 0.1.0

package/dist/cli/workflow.d.ts

@@ -0,0 +1,10 @@
+interface WorkflowOptions {
+    run?: string;
+    list?: boolean;
+    show?: string;
+    status?: boolean;
+    reset?: boolean;
+    create?: string;
+}
+export declare function handleWorkflow(options: WorkflowOptions): Promise<void>;
+export {};

package/dist/cli/workflow.js

@@ -0,0 +1,594 @@
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+const WORKFLOWS_DIR = ".archbyte/workflows";
+const STATE_DIR = ".archbyte/workflows/.state";
+// ── Built-in workflows ──
+const BUILTIN_WORKFLOWS = [
+    {
+        id: "full-analysis",
+        name: "Full Analysis Pipeline",
+        description: "Complete architecture pipeline: analyze, generate, validate, and report",
+        steps: [
+            {
+                id: "generate",
+                name: "Generate Diagram",
+                command: "archbyte generate",
+                needs: [],
+                description: "Generate architecture diagram from analysis JSON",
+            },
+            {
+                id: "validate",
+                name: "Validate Architecture",
+                command: "archbyte validate",
+                needs: ["generate"],
+                description: "Run fitness function rules against the architecture",
+            },
+            {
+                id: "stats",
+                name: "Architecture Stats",
+                command: "archbyte stats",
+                needs: ["generate"],
+                description: "Display architecture health metrics",
+            },
+            {
+                id: "export",
+                name: "Export Mermaid",
+                command: "archbyte export --format mermaid",
+                needs: ["generate"],
+                description: "Export architecture as Mermaid diagram",
+            },
+        ],
+    },
+    {
+        id: "ci-check",
+        name: "CI Architecture Check",
+        description: "Lightweight CI pipeline: validate and diff against baseline",
+        steps: [
+            {
+                id: "validate",
+                name: "Validate",
+                command: "archbyte validate --ci",
+                needs: [],
+                description: "Run validation in CI mode (JSON output, exit code on failure)",
+            },
+        ],
+    },
+    {
+        id: "drift-check",
+        name: "Architecture Drift Check",
+        description: "Check for architecture drift by comparing against a baseline snapshot",
+        steps: [
+            {
+                id: "snapshot",
+                name: "Snapshot Baseline",
+                command: "cp .archbyte/architecture.json .archbyte/baseline.json",
+                needs: [],
+                description: "Save current architecture as baseline for drift detection",
+            },
+            {
+                id: "generate",
+                name: "Regenerate",
+                command: "archbyte generate",
+                needs: ["snapshot"],
+                description: "Regenerate architecture from latest analysis",
+            },
+            {
+                id: "diff",
+                name: "Diff",
+                command: "archbyte diff --baseline .archbyte/baseline.json",
+                needs: ["generate"],
+                description: "Compare regenerated architecture against baseline",
+            },
+        ],
+    },
+];
+// ── YAML parser for workflow files ──
+function parseWorkflowYaml(content, filePath) {
+    const lines = content.split("\n");
+    const def = { steps: [] };
+    let inSteps = false;
+    let currentStep = null;
+    const flushStep = () => {
+        if (currentStep?.id && currentStep.name && currentStep.command) {
+            def.steps.push({
+                id: currentStep.id,
+                name: currentStep.name,
+                command: currentStep.command,
+                needs: currentStep.needs || [],
+                description: currentStep.description,
+                retries: currentStep.retries,
+                continueOnFail: currentStep.continueOnFail,
+                compensation: currentStep.compensation,
+            });
+        }
+        currentStep = null;
+    };
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        // Top-level keys
+        const topMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+        if (topMatch && !inSteps) {
+            const [, key, val] = topMatch;
+            if (key === "id")
+                def.id = val.replace(/^["']|["']$/g, "");
+            if (key === "name")
+                def.name = val.replace(/^["']|["']$/g, "");
+            if (key === "description")
+                def.description = val.replace(/^["']|["']$/g, "");
+            if (key === "steps") {
+                inSteps = true;
+            }
+            continue;
+        }
+        if (!inSteps)
+            continue;
+        // Exit steps on new top-level key
+        if (/^\w/.test(trimmed) && trimmed !== "" && !trimmed.startsWith("#")) {
+            flushStep();
+            inSteps = false;
+            continue;
+        }
+        if (trimmed === "" || trimmed.trim().startsWith("#"))
+            continue;
+        // New step item: "  - id: xxx"
+        const itemMatch = trimmed.match(/^ {2}- id:\s*(.+)$/);
+        if (itemMatch) {
+            flushStep();
+            currentStep = { id: itemMatch[1].replace(/^["']|["']$/g, ""), needs: [] };
+            continue;
+        }
+        if (!currentStep)
+            continue;
+        // Step properties
+        const propMatch = trimmed.match(/^ {4}(\w+):\s*(.+)$/);
+        if (propMatch) {
+            const [, key, val] = propMatch;
+            const cleanVal = val.replace(/^["']|["']$/g, "");
+            if (key === "name")
+                currentStep.name = cleanVal;
+            if (key === "command")
+                currentStep.command = cleanVal;
+            if (key === "description")
+                currentStep.description = cleanVal;
+            if (key === "needs") {
+                // Parse: [step1, step2] or [] or step1
+                if (val.trim() === "[]") {
+                    currentStep.needs = [];
+                }
+                else {
+                    const bracketMatch = val.match(/^\[(.+)\]$/);
+                    if (bracketMatch) {
+                        currentStep.needs = bracketMatch[1]
+                            .split(",")
+                            .map((s) => s.trim().replace(/^["']|["']$/g, ""));
+                    }
+                    else {
+                        currentStep.needs = [cleanVal];
+                    }
+                }
+            }
+            if (key === "retries")
+                currentStep.retries = parseInt(cleanVal, 10) || 0;
+            if (key === "continueOnFail")
+                currentStep.continueOnFail = cleanVal === "true";
+            if (key === "compensation")
+                currentStep.compensation = cleanVal;
+        }
+    }
+    flushStep();
+    if (!def.id || !def.name || !def.steps || def.steps.length === 0) {
+        console.error(chalk.yellow(`  Warning: Invalid workflow file: ${filePath}`));
+        return null;
+    }
+    return def;
+}
+// ── Workflow loading ──
+function loadWorkflows() {
+    const workflows = [...BUILTIN_WORKFLOWS];
+    const dir = path.join(process.cwd(), WORKFLOWS_DIR);
+    if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const def = parseWorkflowYaml(content, file);
+            if (def) {
+                // Custom workflows override built-ins with the same id
+                const idx = workflows.findIndex((w) => w.id === def.id);
+                if (idx >= 0)
+                    workflows[idx] = def;
+                else
+                    workflows.push(def);
+            }
+        }
+    }
+    return workflows;
+}
+function findWorkflow(id) {
+    const workflows = loadWorkflows();
+    return workflows.find((w) => w.id === id) || null;
+}
+// ── State management ──
+function ensureStateDir() {
+    const dir = path.join(process.cwd(), STATE_DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function statePath(workflowId) {
+    return path.join(ensureStateDir(), `${workflowId}.json`);
+}
+function loadState(workflowId) {
+    const p = statePath(workflowId);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveState(state) {
+    fs.writeFileSync(statePath(state.workflowId), JSON.stringify(state, null, 2), "utf-8");
+}
+function clearState(workflowId) {
+    const p = statePath(workflowId);
+    if (fs.existsSync(p))
+        fs.unlinkSync(p);
+}
+// ── Topological sort ──
+function topoSort(steps) {
+    const stepMap = new Map(steps.map((s) => [s.id, s]));
+    const visited = new Set();
+    const sorted = [];
+    function visit(id) {
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        const step = stepMap.get(id);
+        if (!step)
+            return;
+        for (const dep of step.needs) {
+            visit(dep);
+        }
+        sorted.push(step);
+    }
+    for (const step of steps) {
+        visit(step.id);
+    }
+    return sorted;
+}
+// ── Execution ──
+async function executeStep(step) {
+    const { execSync } = await import("child_process");
+    const maxRetries = step.retries ?? 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            execSync(step.command, {
+                cwd: process.cwd(),
+                stdio: "inherit",
+                env: { ...process.env },
+            });
+            return { success: true };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (attempt < maxRetries) {
+                console.log(chalk.yellow(`         Retry ${attempt + 1}/${maxRetries}...`));
+                continue;
+            }
+            return { success: false, error: msg };
+        }
+    }
+    return { success: false, error: "Exhausted retries" };
+}
+async function executeCompensation(step) {
+    if (!step.compensation)
+        return;
+    const { execSync } = await import("child_process");
+    console.log(chalk.yellow(`  [comp] Running compensation for ${step.name}`));
+    console.log(chalk.gray(`         $ ${step.compensation}`));
+    try {
+        execSync(step.compensation, {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            env: { ...process.env },
+        });
+        console.log(chalk.yellow(`  [comp] Compensation completed for ${step.name}`));
+    }
+    catch {
+        console.log(chalk.red(`  [comp] Compensation failed for ${step.name}`));
+    }
+}
+async function runWorkflow(workflow) {
+    const sorted = topoSort(workflow.steps);
+    // Check for existing state (resume support)
+    let state = loadState(workflow.id);
+    const isResume = state !== null && (state.status === "running" || state.status === "failed");
+    if (!state || state.status === "completed") {
+        state = {
+            workflowId: workflow.id,
+            startedAt: new Date().toISOString(),
+            status: "running",
+            steps: {},
+        };
+        for (const step of sorted) {
+            state.steps[step.id] = { status: "pending" };
+        }
+        saveState(state);
+    }
+    else if (state.status === "failed") {
+        // Reset failed steps to pending so they can be retried
+        state.status = "running";
+        for (const [id, stepState] of Object.entries(state.steps)) {
+            if (stepState.status === "failed" || stepState.status === "running") {
+                state.steps[id] = { status: "pending" };
+            }
+        }
+        saveState(state);
+    }
+    if (isResume) {
+        console.log(chalk.yellow("  Resuming interrupted workflow..."));
+        const completed = Object.entries(state.steps)
+            .filter(([, s]) => s.status === "completed")
+            .map(([id]) => id);
+        if (completed.length > 0) {
+            console.log(chalk.gray(`  Already completed: ${completed.join(", ")}`));
+        }
+    }
+    console.log();
+    for (const step of sorted) {
+        const stepState = state.steps[step.id];
+        // Skip already completed steps (resume)
+        if (stepState?.status === "completed") {
+            console.log(chalk.green(`  [done] ${step.name}`));
+            continue;
+        }
+        // Check dependencies
+        const unmetDeps = step.needs.filter((dep) => state.steps[dep]?.status !== "completed");
+        if (unmetDeps.length > 0) {
+            console.log(chalk.yellow(`  [skip] ${step.name} — waiting on: ${unmetDeps.join(", ")}`));
+            state.steps[step.id] = { status: "pending" };
+            saveState(state);
+            continue;
+        }
+        // Execute
+        console.log(chalk.cyan(`  [run]  ${step.name}`));
+        if (step.description) {
+            console.log(chalk.gray(`         ${step.description}`));
+        }
+        console.log(chalk.gray(`         $ ${step.command}`));
+        console.log();
+        state.steps[step.id] = {
+            status: "running",
+            startedAt: new Date().toISOString(),
+        };
+        saveState(state);
+        const result = await executeStep(step);
+        if (result.success) {
+            state.steps[step.id] = {
+                status: "completed",
+                startedAt: state.steps[step.id].startedAt,
+                completedAt: new Date().toISOString(),
+            };
+            saveState(state);
+            console.log();
+            console.log(chalk.green(`  [done] ${step.name}`));
+        }
+        else {
+            state.steps[step.id] = {
+                status: "failed",
+                startedAt: state.steps[step.id].startedAt,
+                error: result.error,
+            };
+            saveState(state);
+            console.log();
+            console.log(chalk.red(`  [fail] ${step.name}`));
+            console.log(chalk.red(`         ${result.error}`));
+            // Run compensation if defined
+            await executeCompensation(step);
+            // If continueOnFail is set, skip this step and continue the pipeline
+            if (step.continueOnFail) {
+                console.log(chalk.yellow(`  [skip] Continuing despite failure (continueOnFail)`));
+            }
+            else {
+                state.status = "failed";
+                saveState(state);
+                console.log();
+                console.log(chalk.yellow(`  Workflow paused. Fix the issue and run again to resume.`));
+                return;
+            }
+        }
+        console.log();
+    }
+    // All done
+    state.status = "completed";
+    saveState(state);
+    console.log(chalk.green.bold("  Workflow completed successfully!"));
+    console.log();
+}
+// ── Display ──
+function listWorkflows() {
+    const workflows = loadWorkflows();
+    const projectName = process.cwd().split("/").pop() || "project";
+    console.log();
+    console.log(chalk.bold.cyan(`  ArchByte Workflows — ${projectName}`));
+    console.log();
+    for (const w of workflows) {
+        const state = loadState(w.id);
+        let statusStr = chalk.gray("ready");
+        if (state?.status === "running")
+            statusStr = chalk.yellow("in progress");
+        if (state?.status === "completed")
+            statusStr = chalk.green("completed");
+        if (state?.status === "failed")
+            statusStr = chalk.red("failed");
+        const builtinTag = BUILTIN_WORKFLOWS.some((b) => b.id === w.id)
+            ? chalk.gray(" (built-in)")
+            : "";
+        console.log(`  ${chalk.bold(w.id)}${builtinTag} — ${statusStr}`);
+        console.log(chalk.gray(`    ${w.description}`));
+        console.log(chalk.gray(`    Steps: ${w.steps.map((s) => s.id).join(" → ")}`));
+        console.log();
+    }
+}
+function showWorkflow(id) {
+    const workflow = findWorkflow(id);
+    if (!workflow) {
+        console.error(chalk.red(`  Workflow not found: ${id}`));
+        console.error(chalk.gray("  Run archbyte workflow --list to see available workflows"));
+        process.exit(1);
+    }
+    const state = loadState(id);
+    console.log();
+    console.log(chalk.bold.cyan(`  Workflow: ${workflow.name}`));
+    console.log(chalk.gray(`  ${workflow.description}`));
+    if (state) {
+        console.log(chalk.gray(`  Started: ${state.startedAt}`));
+        console.log(chalk.gray(`  Status: ${state.status}`));
+    }
+    console.log();
+    const sorted = topoSort(workflow.steps);
+    for (const step of sorted) {
+        const stepState = state?.steps[step.id];
+        let icon = chalk.gray("*");
+        let statusLabel = "";
+        if (stepState?.status === "completed") {
+            icon = chalk.green("done");
+            statusLabel = chalk.gray(` (${stepState.completedAt})`);
+        }
+        else if (stepState?.status === "running") {
+            icon = chalk.yellow(">>>");
+        }
+        else if (stepState?.status === "failed") {
+            icon = chalk.red("FAIL");
+            statusLabel = chalk.red(` — ${stepState.error?.slice(0, 60)}`);
+        }
+        const depsStr = step.needs.length > 0
+            ? chalk.gray(` [needs: ${step.needs.join(", ")}]`)
+            : "";
+        console.log(`  ${icon} ${chalk.bold(step.name)}${depsStr}${statusLabel}`);
+        console.log(chalk.gray(`       $ ${step.command}`));
+        if (step.description) {
+            console.log(chalk.gray(`       ${step.description}`));
+        }
+        console.log();
+    }
+}
+function showStatus() {
+    const workflows = loadWorkflows();
+    const projectName = process.cwd().split("/").pop() || "project";
+    console.log();
+    console.log(chalk.bold.cyan(`  Workflow Status — ${projectName}`));
+    console.log();
+    let anyActive = false;
+    for (const w of workflows) {
+        const state = loadState(w.id);
+        if (!state)
+            continue;
+        anyActive = true;
+        const completed = Object.values(state.steps).filter((s) => s.status === "completed").length;
+        const total = Object.keys(state.steps).length;
+        const pct = Math.round((completed / total) * 100);
+        const barLen = Math.round((completed / total) * 20);
+        const bar = chalk.green("=".repeat(barLen)) + chalk.gray("-".repeat(20 - barLen));
+        let statusIcon = chalk.yellow("running");
+        if (state.status === "completed")
+            statusIcon = chalk.green("done");
+        if (state.status === "failed")
+            statusIcon = chalk.red("failed");
+        console.log(`  ${chalk.bold(w.id)} [${bar}] ${pct}% — ${statusIcon}`);
+        console.log(chalk.gray(`    ${completed}/${total} steps complete`));
+        console.log();
+    }
+    if (!anyActive) {
+        console.log(chalk.gray("  No active workflows. Run archbyte workflow --run <id> to start one."));
+        console.log();
+    }
+}
+function createWorkflowFile(name) {
+    const dir = path.join(process.cwd(), WORKFLOWS_DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const id = name.replace(/\s+/g, "-").toLowerCase();
+    const filePath = path.join(dir, `${id}.yaml`);
+    if (fs.existsSync(filePath)) {
+        console.error(chalk.red(`  Workflow file already exists: ${filePath}`));
+        process.exit(1);
+    }
+    const template = `id: ${id}
+name: "${name}"
+description: "Custom architecture workflow"
+
+steps:
+  - id: step-1
+    name: "First Step"
+    command: "echo 'Step 1'"
+    needs: []
+    description: "Replace with your command"
+
+  - id: step-2
+    name: "Second Step"
+    command: "echo 'Step 2'"
+    needs: [step-1]
+    description: "Runs after step-1 completes"
+`;
+    fs.writeFileSync(filePath, template, "utf-8");
+    console.log(chalk.green(`  Created workflow: ${path.relative(process.cwd(), filePath)}`));
+    console.log(chalk.gray(`  Edit it to define your pipeline steps, then run:`));
+    console.log(chalk.cyan(`  archbyte workflow --run ${id}`));
+}
+// ── Main handler ──
+export async function handleWorkflow(options) {
+    if (options.list) {
+        listWorkflows();
+        return;
+    }
+    if (options.show) {
+        showWorkflow(options.show);
+        return;
+    }
+    if (options.status) {
+        showStatus();
+        return;
+    }
+    if (options.create) {
+        createWorkflowFile(options.create);
+        return;
+    }
+    if (options.reset) {
+        // Reset all workflow states
+        const stateDir = path.join(process.cwd(), STATE_DIR);
+        if (fs.existsSync(stateDir)) {
+            const files = fs.readdirSync(stateDir).filter((f) => f.endsWith(".json"));
+            for (const f of files) {
+                fs.unlinkSync(path.join(stateDir, f));
+            }
+            console.log(chalk.green(`  Reset ${files.length} workflow state(s).`));
+        }
+        else {
+            console.log(chalk.gray("  No workflow state to reset."));
+        }
+        return;
+    }
+    if (options.run) {
+        const workflow = findWorkflow(options.run);
+        if (!workflow) {
+            console.error(chalk.red(`  Workflow not found: ${options.run}`));
+            console.error(chalk.gray("  Run archbyte workflow --list to see available workflows"));
+            process.exit(1);
+        }
+        const projectName = process.cwd().split("/").pop() || "project";
+        console.log();
+        console.log(chalk.bold.cyan(`  ArchByte Workflow: ${workflow.name} — ${projectName}`));
+        console.log(chalk.gray(`  ${workflow.description}`));
+        console.log(chalk.gray(`  Steps: ${workflow.steps.length}`));
+        await runWorkflow(workflow);
+        return;
+    }
+    // Default: show list
+    listWorkflows();
+}