archbyte 0.1.0

package/dist/cli/analyze.js

@@ -0,0 +1,586 @@
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+import { resolveConfig } from "./config.js";
+import { recordUsage } from "./license-gate.js";
+export async function handleAnalyze(options) {
+    const rootDir = process.cwd();
+    const isStaticOnly = options.static || options.skipLlm;
+    console.log();
+    console.log(chalk.bold.cyan("ArchByte Analyzer"));
+    if (isStaticOnly) {
+        console.log(chalk.gray("Static-only mode: deterministic analysis, no model"));
+    }
+    else {
+        console.log(chalk.gray("Static context + model pipeline"));
+    }
+    console.log();
+    // ─── Dry-run mode ───
+    if (options.dryRun) {
+        const config = resolveConfig();
+        const provider = options.provider ?? config?.provider ?? "none";
+        const mode = isStaticOnly ? "static (no LLM)" : "pipeline (static + LLM)";
+        const diagramPath = path.join(rootDir, ".archbyte", "architecture.json");
+        const diagramExists = fs.existsSync(diagramPath);
+        const outputPath = options.output ?? ".archbyte/analysis.json";
+        console.log(chalk.bold("ArchByte Analyze — Dry Run"));
+        console.log(chalk.gray(`  Project:   ${path.basename(rootDir)}`));
+        console.log(chalk.gray(`  Mode:      ${mode}`));
+        console.log(chalk.gray(`  Provider:  ${provider}`));
+        console.log(chalk.gray(`  Diagram:   ${diagramExists ? "exists" : "not found"}`));
+        console.log(chalk.gray(`  Output:    ${outputPath}`));
+        console.log();
+        console.log(chalk.yellow("No changes made. Remove --dry-run to execute."));
+        console.log();
+        return;
+    }
+    // ─── Premium-only mode (unchanged — uses Orchestrator) ───
+    if (options.premiumOnly) {
+        await runLegacyOrchestrator(rootDir, options, true);
+        return;
+    }
+    // ─── Static-only mode (--static / --skip-llm) ───
+    if (isStaticOnly) {
+        const startTime = Date.now();
+        console.log(chalk.bold("Running static analysis (no model)..."));
+        console.log();
+        const { runStaticAnalysis } = await import("../agents/static/index.js");
+        const result = await runStaticAnalysis(rootDir, (msg) => {
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            console.log(chalk.gray(`  [${elapsed}s] ${msg}`));
+        });
+        const analysis = buildAnalysisFromStatic(result, rootDir);
+        const duration = Date.now() - startTime;
+        // Stamp scan metadata
+        const meta = analysis.metadata;
+        meta.durationMs = duration;
+        meta.mode = "static";
+        writeAnalysis(rootDir, analysis);
+        await autoGenerate(rootDir, options);
+        printSummary(analysis, duration, "static");
+        return;
+    }
+    // ─── Default mode: static context → LLM pipeline ───
+    // 1. Resolve LLM config
+    let config = resolveConfig();
+    if (options.provider) {
+        config = {
+            provider: options.provider,
+            apiKey: options.apiKey ?? config?.apiKey ?? "",
+            ollamaBaseUrl: config?.ollamaBaseUrl,
+        };
+    }
+    if (options.apiKey && config) {
+        config.apiKey = options.apiKey;
+    }
+    if (!config) {
+        console.error(chalk.red("No model provider configured."));
+        console.error();
+        console.error(chalk.bold("Set up with:"));
+        console.error(chalk.gray("  archbyte config set provider anthropic"));
+        console.error(chalk.gray("  archbyte config set api-key sk-ant-..."));
+        console.error();
+        console.error(chalk.bold("Or use environment variables:"));
+        console.error(chalk.gray("  export ARCHBYTE_PROVIDER=anthropic"));
+        console.error(chalk.gray("  export ARCHBYTE_API_KEY=sk-ant-..."));
+        console.error();
+        console.error(chalk.bold("Or run without a model:"));
+        console.error(chalk.gray("  archbyte analyze --static"));
+        console.error();
+        console.error(chalk.bold("Supported providers:"));
+        console.error(chalk.gray("  anthropic, openai, google, ollama"));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`Provider: ${chalk.white(config.provider)}`));
+    console.log(chalk.gray(`Project:  ${chalk.white(path.basename(rootDir))}`));
+    console.log();
+    // 2. Create provider
+    const { createProvider } = await import("../agents/providers/router.js");
+    let provider;
+    try {
+        provider = createProvider(config);
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to create ${config.provider} provider: ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+    // 3. Run static context collection → LLM pipeline
+    const startTime = Date.now();
+    console.log(chalk.bold("Phase 1: Collecting static context..."));
+    const { runStaticContextCollection } = await import("../agents/static/index.js");
+    const ctx = await runStaticContextCollection(rootDir, (msg) => {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(chalk.gray(`  [${elapsed}s] ${msg}`));
+    });
+    // Save static context for debugging / re-runs
+    const ctxPath = path.join(rootDir, ".archbyte", "static-context.json");
+    if (!fs.existsSync(path.dirname(ctxPath))) {
+        fs.mkdirSync(path.dirname(ctxPath), { recursive: true });
+    }
+    fs.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2), "utf-8");
+    console.log(chalk.gray(`  Saved static context to: .archbyte/static-context.json`));
+    console.log();
+    console.log(chalk.bold("Phase 2: Running model pipeline (3 parallel + 2 sequential)..."));
+    const { runPipeline } = await import("../agents/pipeline/index.js");
+    let result;
+    try {
+        result = await runPipeline(ctx, provider, config, (msg) => {
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            console.log(chalk.gray(`  [${elapsed}s] ${msg}`));
+        });
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        writeAnalysisStatus(rootDir, "error", errorMsg);
+        console.error(chalk.yellow(`\n  Pipeline failed: ${errorMsg}`));
+        console.log(chalk.bold.cyan("\n  Falling back to static-only analysis..."));
+        try {
+            const { runStaticAnalysis } = await import("../agents/static/index.js");
+            const staticResult = await runStaticAnalysis(rootDir, (msg) => {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                console.log(chalk.gray(`  [${elapsed}s] ${msg}`));
+            });
+            const analysis = buildAnalysisFromStatic(staticResult, rootDir);
+            const duration = Date.now() - startTime;
+            const meta = analysis.metadata;
+            meta.durationMs = duration;
+            meta.mode = "static-fallback";
+            meta.pipelineError = errorMsg;
+            writeAnalysis(rootDir, analysis);
+            writeAnalysisStatus(rootDir, "success");
+            await autoGenerate(rootDir, options);
+            printSummary(analysis, duration, "static");
+        }
+        catch (fallbackErr) {
+            console.error(chalk.red(`  Static fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`));
+            process.exit(1);
+        }
+        return;
+    }
+    console.log();
+    // 4. Convert to analysis.json format and write
+    const analysis = buildAnalysisFromStatic(result, rootDir);
+    const duration = Date.now() - startTime;
+    // Stamp scan metadata
+    const meta = analysis.metadata;
+    meta.durationMs = duration;
+    meta.filesScanned = ctx.fileTree.totalFiles;
+    meta.mode = "pipeline";
+    if (result.tokenUsage) {
+        meta.tokenUsage = { input: result.tokenUsage.input, output: result.tokenUsage.output };
+    }
+    writeAnalysis(rootDir, analysis);
+    writeAnalysisStatus(rootDir, "success");
+    await autoGenerate(rootDir, options);
+    // Record usage (best-effort, non-blocking)
+    recordUsage({
+        projectName: path.basename(rootDir),
+        agentCount: 5,
+        durationMs: duration,
+    });
+    printSummary(analysis, duration, "pipeline");
+}
+// ─── Legacy orchestrator (--legacy and --premium-only) ───
+async function runLegacyOrchestrator(rootDir, options, premiumOnly) {
+    // Resolve LLM config
+    let config = resolveConfig();
+    if (options.provider) {
+        config = {
+            provider: options.provider,
+            apiKey: options.apiKey ?? config?.apiKey ?? "",
+            ollamaBaseUrl: config?.ollamaBaseUrl,
+        };
+    }
+    if (options.apiKey && config) {
+        config.apiKey = options.apiKey;
+    }
+    if (!config) {
+        console.error(chalk.red("No model provider configured."));
+        console.error(chalk.gray("  archbyte config set provider anthropic"));
+        console.error(chalk.gray("  archbyte config set api-key sk-ant-..."));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`Provider: ${chalk.white(config.provider)}`));
+    console.log(chalk.gray(`Project:  ${chalk.white(path.basename(rootDir))}`));
+    console.log();
+    const { createProvider } = await import("../agents/providers/router.js");
+    const { Orchestrator } = await import("../agents/runtime/orchestrator.js");
+    const { LocalFSBackend } = await import("../agents/tools/local-fs.js");
+    const { CORE_AGENTS, loadPremiumAgents } = await import("../agents/index.js");
+    let provider;
+    try {
+        provider = createProvider(config);
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to create ${config.provider} provider: ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+    const tools = new LocalFSBackend(rootDir);
+    // Build license — use server-verified tier cache, not unverified JWT
+    const { loadCredentials, getVerifiedTier } = await import("./auth.js");
+    const creds = loadCredentials();
+    const verifiedTier = getVerifiedTier();
+    const license = {
+        tier: verifiedTier,
+        userId: "local",
+        email: creds?.email ?? "local",
+        scansUsed: 0,
+        scansAllowed: -1, // unlimited for all tiers
+        expiresAt: creds?.expiresAt ?? new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+        isValid: true,
+    };
+    const orchestrator = new Orchestrator({ provider, tools, projectRoot: rootDir, config, license });
+    // Premium agents loaded dynamically (not shipped in npm package)
+    const PREMIUM_AGENTS = await loadPremiumAgents();
+    const ALL_AGENTS = [...CORE_AGENTS, ...PREMIUM_AGENTS];
+    if (premiumOnly) {
+        if (PREMIUM_AGENTS.length === 0) {
+            console.error(chalk.red("Premium agents are not available in this installation."));
+            process.exit(1);
+        }
+        orchestrator.registerAll(PREMIUM_AGENTS);
+    }
+    else {
+        orchestrator.registerAll(ALL_AGENTS);
+    }
+    const activeAgents = premiumOnly
+        ? PREMIUM_AGENTS
+        : license.tier === "premium" && PREMIUM_AGENTS.length > 0
+            ? ALL_AGENTS
+            : CORE_AGENTS;
+    const startTime = Date.now();
+    console.log(chalk.bold("Running legacy analysis pipeline..."));
+    console.log(chalk.gray(`Agents: ${activeAgents.length} (${activeAgents.filter(a => a.phase === "parallel").length} parallel, ${activeAgents.filter(a => a.phase === "sequential").length} sequential)`));
+    if (license.tier === "premium") {
+        console.log(chalk.magenta(`  Pro agents: ${PREMIUM_AGENTS.length}`));
+    }
+    console.log();
+    const result = await orchestrator.run((msg) => {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(chalk.gray(`  [${elapsed}s] ${msg}`));
+    });
+    console.log();
+    if (result.errors.length > 0) {
+        console.log(chalk.yellow(`Completed with ${result.errors.length} error(s):`));
+        for (const err of result.errors) {
+            console.log(chalk.red(`  ${err.agentId}: ${err.error}`));
+        }
+        console.log();
+    }
+    const archbyteDir = path.join(rootDir, ".archbyte");
+    if (!fs.existsSync(archbyteDir)) {
+        fs.mkdirSync(archbyteDir, { recursive: true });
+    }
+    if (premiumOnly) {
+        const premiumResults = result.agents.map((a) => ({
+            agentId: a.agentId,
+            confidence: a.confidence,
+            timestamp: new Date().toISOString(),
+            data: a.data,
+        }));
+        const premiumPath = path.join(archbyteDir, "premium-results.json");
+        fs.writeFileSync(premiumPath, JSON.stringify(premiumResults, null, 2), "utf-8");
+        console.log(chalk.green(`Saved premium results to: ${path.relative(rootDir, premiumPath)}`));
+    }
+    else {
+        const analysis = buildAnalysis(result.agents, rootDir);
+        writeAnalysis(rootDir, analysis);
+        await autoGenerate(rootDir, options);
+    }
+    // Telemetry
+    const telemetry = {
+        timestamp: new Date().toISOString(),
+        provider: config.provider,
+        totalDuration: result.totalDuration,
+        agents: result.agents.map((a) => ({
+            id: a.agentId,
+            duration: a.duration,
+            confidence: a.confidence,
+        })),
+        errors: result.errors,
+    };
+    const telemetryPath = path.join(archbyteDir, "telemetry.json");
+    fs.writeFileSync(telemetryPath, JSON.stringify(telemetry, null, 2), "utf-8");
+    recordUsage({
+        projectName: path.basename(rootDir),
+        agentCount: result.agents.length,
+        durationMs: result.totalDuration,
+    });
+    // Summary
+    console.log();
+    console.log(chalk.bold.green(premiumOnly ? "Pro analysis complete!" : "Legacy analysis complete!"));
+    console.log(chalk.gray(`  Duration: ${(result.totalDuration / 1000).toFixed(1)}s`));
+    console.log(chalk.gray(`  Agents:   ${result.agents.length}/${activeAgents.length} succeeded`));
+    if (!premiumOnly) {
+        const analysisPath = path.join(rootDir, ".archbyte", "analysis.json");
+        try {
+            const analysis = JSON.parse(fs.readFileSync(analysisPath, "utf-8"));
+            console.log(chalk.gray(`  Components: ${(analysis.components ?? []).length}`));
+            console.log(chalk.gray(`  Connections: ${(analysis.connections ?? []).length}`));
+        }
+        catch { /* ignore */ }
+    }
+    console.log();
+    if (premiumOnly) {
+        console.log(chalk.bold("Results saved to .archbyte/premium-results.json"));
+    }
+    else {
+        console.log(chalk.bold("Next steps:"));
+        console.log(chalk.gray(`  ${chalk.cyan("archbyte serve")}    -- view the architecture diagram`));
+        console.log(chalk.gray(`  ${chalk.cyan("archbyte validate")} -- check architecture fitness rules`));
+        console.log(chalk.gray(`  ${chalk.cyan("archbyte export")}   -- export to mermaid, plantuml, etc.`));
+    }
+    console.log();
+}
+// ─── Shared helpers ───
+function writeAnalysisStatus(rootDir, status, error) {
+    const archbyteDir = path.join(rootDir, ".archbyte");
+    if (!fs.existsSync(archbyteDir)) {
+        fs.mkdirSync(archbyteDir, { recursive: true });
+    }
+    const statusPath = path.join(archbyteDir, "analysis-status.json");
+    fs.writeFileSync(statusPath, JSON.stringify({
+        status,
+        ...(error ? { error } : {}),
+        timestamp: new Date().toISOString(),
+    }, null, 2), "utf-8");
+}
+function writeAnalysis(rootDir, analysis) {
+    const archbyteDir = path.join(rootDir, ".archbyte");
+    if (!fs.existsSync(archbyteDir)) {
+        fs.mkdirSync(archbyteDir, { recursive: true });
+    }
+    const analysisPath = path.join(archbyteDir, "analysis.json");
+    fs.writeFileSync(analysisPath, JSON.stringify(analysis, null, 2), "utf-8");
+    console.log(chalk.green(`Saved analysis to: ${path.relative(rootDir, analysisPath)}`));
+}
+async function autoGenerate(rootDir, options) {
+    console.log();
+    console.log(chalk.gray("Generating architecture diagram..."));
+    const analysisPath = path.join(rootDir, ".archbyte", "analysis.json");
+    try {
+        const { handleGenerate } = await import("./generate.js");
+        await handleGenerate({ input: analysisPath, verbose: options.verbose });
+    }
+    catch (err) {
+        console.error(chalk.yellow(`Warning: diagram generation failed: ${err instanceof Error ? err.message : err}`));
+        console.error(chalk.gray("You can run 'archbyte generate' manually."));
+    }
+}
+function printSummary(analysis, durationMs, mode) {
+    const components = analysis.components ?? [];
+    const connections = analysis.connections ?? [];
+    console.log();
+    console.log(chalk.bold.green("Analysis complete!"));
+    console.log(chalk.gray(`  Mode:        ${mode === "pipeline" ? "static + agents" : "static"}`));
+    console.log(chalk.gray(`  Duration:    ${(durationMs / 1000).toFixed(1)}s`));
+    console.log(chalk.gray(`  Components:  ${components.length}`));
+    console.log(chalk.gray(`  Connections: ${connections.length}`));
+    console.log();
+    console.log(chalk.bold("Next steps:"));
+    console.log(chalk.gray(`  ${chalk.cyan("archbyte serve")}    -- view the architecture diagram`));
+    console.log(chalk.gray(`  ${chalk.cyan("archbyte validate")} -- check architecture fitness rules`));
+    console.log(chalk.gray(`  ${chalk.cyan("archbyte export")}   -- export to mermaid, plantuml, etc.`));
+    console.log();
+}
+// ─── Analysis converters ───
+/**
+ * Convert a StaticAnalysisResult (from pipeline or static-only) into the
+ * flat analysis.json format expected by generate.ts.
+ */
+export function buildAnalysisFromStatic(result, projectRoot) {
+    const allComponents = result.components.components;
+    // Partition components by role
+    const appComponents = allComponents
+        .filter((c) => c.layer !== "external" && c.type !== "database" && c.layer !== "data")
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: mapComponentType(c.type),
+        path: c.path,
+        techStack: c.technologies,
+        description: c.description,
+        layer: c.layer,
+    }));
+    const databases = allComponents
+        .filter((c) => c.type === "database" || c.layer === "data")
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: c.technologies[0] ?? "database",
+    }));
+    const externalServices = allComponents
+        .filter((c) => c.layer === "external")
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: c.technologies[0] ?? "api",
+    }));
+    // Connections
+    const mappedConnections = result.connections.connections.map((c) => ({
+        from: c.from,
+        to: c.to,
+        type: c.type,
+        description: c.description,
+        async: c.async,
+    }));
+    // Environments
+    const environments = result.envs.environments.map((e) => ({
+        name: e.name,
+        label: e.name.charAt(0).toUpperCase() + e.name.slice(1),
+        color: e.name === "production" ? "#ef4444" : e.name === "staging" ? "#f59e0b" : "#22c55e",
+    }));
+    // Flows — only keep steps that are valid "componentId → componentId" pairs
+    const allComponentIds = new Set(allComponents.map((c) => c.id));
+    const flows = result.connections.flows.map((f, i) => ({
+        id: `flow-${i}`,
+        name: f.name,
+        description: f.description,
+        steps: f.steps
+            .map((step) => {
+            const parts = step.split("\u2192").map((s) => s.trim());
+            const from = parts[0] ?? "";
+            const to = parts[1] ?? "";
+            return { from, to, label: step };
+        })
+            .filter((s) => s.from && s.to && allComponentIds.has(s.from) && allComponentIds.has(s.to)),
+    })).filter((f) => f.steps.length > 0);
+    return {
+        project: {
+            name: result.structure.projectName ?? path.basename(projectRoot),
+            description: result.docs.projectDescription ?? "",
+            primaryLanguage: result.structure.language,
+            isMonorepo: result.structure.isMonorepo,
+        },
+        components: appComponents,
+        databases,
+        externalServices,
+        connections: mappedConnections,
+        environments,
+        flows,
+        metadata: {
+            analyzedAt: new Date().toISOString(),
+            validation: result.validation,
+            gaps: result.gaps,
+        },
+    };
+}
+/**
+ * Aggregate agent results into the analysis.json format expected by the generator.
+ * Used by legacy mode (--legacy flag) only.
+ */
+export function buildAnalysis(agents, projectRoot) {
+    const getAgentData = (id) => {
+        const agent = agents.find((a) => a.agentId === id);
+        if (!agent?.data || typeof agent.data !== "object")
+            return {};
+        return agent.data;
+    };
+    const structure = getAgentData("structure-scanner");
+    const components = getAgentData("component-detector");
+    const connections = getAgentData("connection-mapper");
+    const docs = getAgentData("doc-parser");
+    const envs = getAgentData("env-detector");
+    const validation = getAgentData("validator");
+    const componentList = components.components ?? [];
+    const mappedComponents = componentList.map((c, i) => ({
+        id: slugify(c.name) ?? `component-${i}`,
+        name: c.name ?? `Component ${i}`,
+        type: mapComponentType(c.type),
+        path: c.path ?? "",
+        techStack: c.technologies ?? [],
+        description: c.description ?? "",
+        layer: c.layer ?? "application",
+    }));
+    const connectionList = connections.connections ?? [];
+    const mappedConnections = connectionList.map((c) => ({
+        from: slugify(c.source) ?? "",
+        to: slugify(c.target) ?? "",
+        type: c.type ?? "import",
+        description: c.label ?? "",
+        async: c.style === "dashed",
+    }));
+    const databases = mappedComponents
+        .filter((c) => c.type === "database" || c.layer === "data")
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: "postgresql",
+    }));
+    const externalServices = mappedComponents
+        .filter((c) => c.layer === "external")
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: "api",
+    }));
+    const appComponents = mappedComponents.filter((c) => c.layer !== "external" && c.type !== "database");
+    const envList = envs.environments ?? [];
+    const environments = envList.map((e) => ({
+        name: e.name ?? "default",
+        label: (e.name ?? "default").charAt(0).toUpperCase() + (e.name ?? "default").slice(1),
+        color: e.name === "production" ? "#ef4444" : e.name === "staging" ? "#f59e0b" : "#22c55e",
+    }));
+    const flowList = connections.flows ?? [];
+    const flows = flowList.map((f, i) => ({
+        id: `flow-${i}`,
+        name: f.name ?? `Flow ${i}`,
+        description: f.description ?? "",
+        steps: (f.steps ?? []).map((step) => {
+            const parts = step.split("\u2192").map((s) => s.trim());
+            return {
+                from: slugify(parts[0]) ?? "",
+                to: slugify(parts[1]) ?? "",
+                label: step,
+            };
+        }),
+    }));
+    return {
+        project: {
+            name: structure.projectName ?? path.basename(projectRoot),
+            description: docs.projectDescription ?? "",
+            primaryLanguage: structure.language,
+            isMonorepo: structure.isMonorepo ?? false,
+        },
+        components: appComponents,
+        databases,
+        externalServices,
+        connections: mappedConnections,
+        environments,
+        flows,
+        metadata: {
+            analyzedAt: new Date().toISOString(),
+            agentResults: agents.map((a) => ({
+                id: a.agentId,
+                confidence: a.confidence,
+            })),
+            validation,
+        },
+    };
+}
+function slugify(name) {
+    if (!name)
+        return undefined;
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function mapComponentType(type) {
+    if (!type)
+        return "service";
+    const t = type.toLowerCase();
+    if (t.includes("frontend") || t.includes("ui") || t.includes("web"))
+        return "frontend";
+    if (t.includes("api") || t.includes("gateway"))
+        return "api";
+    if (t.includes("database") || t.includes("db"))
+        return "database";
+    if (t.includes("worker") || t.includes("job") || t.includes("queue"))
+        return "worker";
+    if (t.includes("library") || t.includes("lib") || t.includes("package"))
+        return "library";
+    if (t.includes("cache"))
+        return "cache";
+    return "service";
+}

package/dist/cli/auth.d.ts

@@ -0,0 +1,46 @@
+interface Credentials {
+    token: string;
+    email: string;
+    tier: string;
+    expiresAt: string;
+}
+export type OAuthProvider = "github" | "google";
+export declare function handleLogin(provider?: OAuthProvider): Promise<void>;
+export declare function handleLoginWithToken(token: string): Promise<void>;
+export declare function handleLogout(): Promise<void>;
+export declare function handleStatus(): Promise<void>;
+export declare function loadCredentials(): Credentials | null;
+/**
+ * Get the tier from the JWT token payload. NEVER falls back to the
+ * editable credentials file — that would allow trivial tier bypass
+ * by editing ~/.archbyte/credentials.json.
+ *
+ * WARNING: This reads from an UNVERIFIED JWT payload. The CLI cannot
+ * verify HMAC signatures (no shared secret). Use getVerifiedTier()
+ * instead, which reads from the server-verified tier cache.
+ */
+export declare function getTierFromToken(): "free" | "premium";
+/**
+ * Cache the server-verified tier. Called by license-gate after a
+ * successful server response. Uses email as the identifier since
+ * the license-gate has access to it from credentials.
+ */
+export declare function cacheVerifiedTier(tier: "free" | "premium", email: string): void;
+/**
+ * Get the tier from the server-verified cache. Returns "free" if cache
+ * is missing, stale (> 1 hour), or belongs to a different user.
+ */
+export declare function getVerifiedTier(): "free" | "premium";
+/**
+ * Check if an offline action is allowed. Returns true if within limits.
+ * Increments the counter when allowed.
+ */
+export declare function checkOfflineAction(): {
+    allowed: boolean;
+    reason?: string;
+};
+/**
+ * Reset offline action counter. Called after successful server verification.
+ */
+export declare function resetOfflineActions(): void;
+export {};