@node-boost/node-boost 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,380 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+declare const architectureSlugSchema: z.ZodEnum<{
+    "feature-modules": "feature-modules";
+    "server-first-components": "server-first-components";
+    "data-access-layer": "data-access-layer";
+    "typed-contracts": "typed-contracts";
+    "state-management": "state-management";
+    "custom-hooks": "custom-hooks";
+    "component-composition": "component-composition";
+    "styling-tailwind": "styling-tailwind";
+    "testing-strategy": "testing-strategy";
+    "error-loading-boundaries": "error-loading-boundaries";
+    "secure-by-default": "secure-by-default";
+    "modern-typescript": "modern-typescript";
+    "ui-states": "ui-states";
+}>;
+declare const featureModulesBoundarySchema: z.ZodEnum<{
+    "public-api": "public-api";
+    forbid: "forbid";
+}>;
+declare const architectureEntrySchema: z.ZodUnion<readonly [z.ZodEnum<{
+    "feature-modules": "feature-modules";
+    "server-first-components": "server-first-components";
+    "data-access-layer": "data-access-layer";
+    "typed-contracts": "typed-contracts";
+    "state-management": "state-management";
+    "custom-hooks": "custom-hooks";
+    "component-composition": "component-composition";
+    "styling-tailwind": "styling-tailwind";
+    "testing-strategy": "testing-strategy";
+    "error-loading-boundaries": "error-loading-boundaries";
+    "secure-by-default": "secure-by-default";
+    "modern-typescript": "modern-typescript";
+    "ui-states": "ui-states";
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"feature-modules">;
+    boundary: z.ZodDefault<z.ZodEnum<{
+        "public-api": "public-api";
+        forbid: "forbid";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodEnum<{
+        "server-first-components": "server-first-components";
+        "data-access-layer": "data-access-layer";
+        "typed-contracts": "typed-contracts";
+        "state-management": "state-management";
+        "custom-hooks": "custom-hooks";
+        "component-composition": "component-composition";
+        "styling-tailwind": "styling-tailwind";
+        "testing-strategy": "testing-strategy";
+        "error-loading-boundaries": "error-loading-boundaries";
+        "secure-by-default": "secure-by-default";
+        "modern-typescript": "modern-typescript";
+        "ui-states": "ui-states";
+    }>;
+}, z.core.$strict>]>;
+declare const nodeBoostConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    generatedWith: z.ZodString;
+    stack: z.ZodEnum<{
+        next: "next";
+        "vite-react": "vite-react";
+        "react-generic": "react-generic";
+        unknown: "unknown";
+    }>;
+    agents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        cursor: "cursor";
+    }>>>;
+    features: z.ZodDefault<z.ZodObject<{
+        guidelines: z.ZodDefault<z.ZodBoolean>;
+        skills: z.ZodDefault<z.ZodBoolean>;
+        mcp: z.ZodDefault<z.ZodBoolean>;
+        architecture: z.ZodDefault<z.ZodBoolean>;
+        hooks: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    architectures: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        "feature-modules": "feature-modules";
+        "server-first-components": "server-first-components";
+        "data-access-layer": "data-access-layer";
+        "typed-contracts": "typed-contracts";
+        "state-management": "state-management";
+        "custom-hooks": "custom-hooks";
+        "component-composition": "component-composition";
+        "styling-tailwind": "styling-tailwind";
+        "testing-strategy": "testing-strategy";
+        "error-loading-boundaries": "error-loading-boundaries";
+        "secure-by-default": "secure-by-default";
+        "modern-typescript": "modern-typescript";
+        "ui-states": "ui-states";
+    }>, z.ZodObject<{
+        name: z.ZodLiteral<"feature-modules">;
+        boundary: z.ZodDefault<z.ZodEnum<{
+            "public-api": "public-api";
+            forbid: "forbid";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodEnum<{
+            "server-first-components": "server-first-components";
+            "data-access-layer": "data-access-layer";
+            "typed-contracts": "typed-contracts";
+            "state-management": "state-management";
+            "custom-hooks": "custom-hooks";
+            "component-composition": "component-composition";
+            "styling-tailwind": "styling-tailwind";
+            "testing-strategy": "testing-strategy";
+            "error-loading-boundaries": "error-loading-boundaries";
+            "secure-by-default": "secure-by-default";
+            "modern-typescript": "modern-typescript";
+            "ui-states": "ui-states";
+        }>;
+    }, z.core.$strict>]>>>;
+    audit: z.ZodDefault<z.ZodObject<{
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            off: "off";
+            warn: "warn";
+            err: "err";
+        }>>>;
+        ruleOptions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type NodeBoostConfig = z.infer<typeof nodeBoostConfigSchema>;
+interface NormalizedArchitecture$1 {
+    name: z.infer<typeof architectureSlugSchema>;
+    options: Record<string, unknown>;
+}
+declare function parseNodeBoostConfig(input: unknown): NodeBoostConfig;
+declare function normalizeArchitectures(config: Pick<NodeBoostConfig, "architectures">): NormalizedArchitecture$1[];
+
+declare function createNodeBoostJsonSchema(): unknown;
+
+type PackageManagerName = "npm" | "pnpm" | "yarn" | "bun";
+interface PackageManagerInfo {
+    name: PackageManagerName;
+    lockfile: string | null;
+    version: string | null;
+    source: "lockfile" | "packageManagerField" | "default";
+}
+type StackName = "next" | "vite-react" | "react-generic" | "unknown";
+type RouterKind = "app" | "pages" | "react-router" | "none" | "unknown";
+type LintingKind = "biome" | "eslint-prettier" | "eslint" | "none";
+interface PackageInfo {
+    name: string;
+    declaredRange: string | null;
+    version: string | null;
+    major: number | null;
+    source: "node_modules" | "range" | "missing";
+}
+interface DetectedStack {
+    rootDir: string;
+    name: StackName;
+    router: RouterKind;
+    srcDir: boolean;
+    linting: LintingKind;
+    packageManager: PackageManagerInfo;
+    packages: Record<string, PackageInfo>;
+    warnings: string[];
+}
+type AgentName = "claude-code" | "codex" | "cursor";
+type FeatureName = "guidelines" | "skills" | "mcp" | "architecture" | "hooks";
+type ArchitectureSlug = "feature-modules" | "server-first-components" | "data-access-layer" | "typed-contracts" | "state-management" | "custom-hooks" | "component-composition" | "styling-tailwind" | "testing-strategy" | "error-loading-boundaries" | "secure-by-default" | "modern-typescript" | "ui-states";
+type FeatureModulesBoundary = "public-api" | "forbid";
+type ArchitectureConfigEntry = ArchitectureSlug | {
+    name: "feature-modules";
+    boundary?: FeatureModulesBoundary;
+} | {
+    name: Exclude<ArchitectureSlug, "feature-modules">;
+};
+interface NormalizedArchitecture {
+    name: ArchitectureSlug;
+    options: Record<string, unknown>;
+}
+interface StackAdapter {
+    name: StackName;
+    label: string;
+    supports(stack: DetectedStack): boolean;
+    recommendedArchitectures(stack: DetectedStack): ArchitectureSlug[];
+    applicableArchitectures(stack: DetectedStack): ArchitectureSlug[];
+}
+interface ResourceSelection {
+    kind: "guideline" | "skill";
+    sourcePath: string;
+    outputPath: string;
+    packageName?: string;
+    packageMajor?: number;
+}
+interface AgentCapabilities {
+    supportsGuidelines: boolean;
+    supportsSkills: boolean;
+    supportsMcp: boolean;
+    supportsHooks: boolean;
+}
+interface Agent {
+    name: AgentName;
+    capabilities: AgentCapabilities;
+}
+
+type AuditSeverity = "err" | "warn";
+interface AuditFinding {
+    rule: string;
+    sev: AuditSeverity;
+    file: string;
+    line: number;
+    code: string;
+    ref?: string;
+}
+interface ExplainEntry {
+    rule: string;
+    code: string;
+    severity: AuditSeverity;
+    architecture: ArchitectureSlug;
+    description: string;
+    rationale: string;
+    fix: string;
+    guideline: string;
+}
+interface AuditResult {
+    v: 1;
+    ok: boolean;
+    cmd: "audit";
+    scope: "all" | "changed" | "base" | "paths";
+    err: number;
+    warn: number;
+    scanned: number;
+    skipped: number;
+    suppressed: number;
+    elapsedMs: number;
+    findings: AuditFinding[];
+}
+
+interface RunAuditOptions {
+    rootDir?: string;
+    mode?: "all" | "changed" | "base" | "paths";
+    base?: string;
+    paths?: string[];
+}
+declare function runAudit(options?: RunAuditOptions): Promise<AuditResult>;
+
+declare function explainFinding(ruleId: string): ExplainEntry | null;
+
+declare function renderAgentReport(result: AuditResult): string;
+
+declare function renderHumanReport(result: AuditResult): string;
+
+declare function detectStack(rootDir: string): Promise<DetectedStack>;
+declare function extractVersionFromRange(range: string | null): string | null;
+declare function parseMajor(version: string): number | null;
+
+declare function detectPackageManager(rootDir: string): Promise<PackageManagerInfo>;
+
+interface NextRouterDetection {
+    router: RouterKind;
+    srcDir: boolean;
+}
+declare function detectNextRouter(rootDir: string): Promise<NextRouterDetection>;
+
+declare function composeGuidelines(rootDir: string, stack: DetectedStack, architectures?: NormalizedArchitecture[]): Promise<ResourceSelection[]>;
+
+declare function composeSkills(rootDir: string, stack: DetectedStack, architectures?: NormalizedArchitecture[]): Promise<ResourceSelection[]>;
+
+declare function renderGuidelinesIndex(stack: DetectedStack, architectures: NormalizedArchitecture[], guidelines: ResourceSelection[]): string;
+
+declare function applyResourceOverrides(projectRoot: string, resources: ResourceSelection[]): Promise<ResourceSelection[]>;
+
+interface FileOperation {
+    path: string;
+    content: string;
+}
+
+interface InstallOptions {
+    cwd?: string;
+    packageRoot?: string;
+    noInteraction?: boolean;
+}
+interface UpdateOptions {
+    cwd?: string;
+    packageRoot?: string;
+}
+interface FileOperationResult extends FileOperation {
+    status: "created" | "updated" | "skipped";
+}
+interface InstallResult {
+    projectRoot: string;
+    stack: DetectedStack;
+    config: NodeBoostConfig;
+    operations: FileOperationResult[];
+}
+declare function runInstall(options?: InstallOptions): Promise<InstallResult>;
+declare function runUpdate(options?: UpdateOptions): Promise<InstallResult>;
+declare function buildInstallOperations(input: {
+    packageRoot: string;
+    projectRoot: string;
+    stack: DetectedStack;
+    config: NodeBoostConfig;
+}): Promise<FileOperation[]>;
+declare function applyFileOperations(projectRoot: string, operations: FileOperation[]): Promise<FileOperationResult[]>;
+
+interface NodeBoostMcpServerOptions {
+    rootDir?: string;
+    packageVersion?: string;
+    includeThrowingTestTool?: boolean;
+}
+declare function createNodeBoostMcpServer(options?: NodeBoostMcpServerOptions): McpServer;
+declare function startNodeBoostMcpServer(options?: NodeBoostMcpServerOptions): Promise<void>;
+
+interface ApplicationInfo {
+    node: string;
+    packageManager: string;
+    typescript: {
+        version: string | null;
+        strict: boolean | null;
+    };
+    stack: {
+        name: string;
+        version: string | null;
+        router: string;
+        srcDir: boolean;
+    };
+    linting: string;
+    packages: Record<string, string>;
+    boost: {
+        version: string;
+        generatedWith: string;
+        architectures: Array<{
+            name: string;
+            options: Record<string, unknown>;
+        }>;
+    } | null;
+    hint?: string;
+}
+declare function applicationInfoTool(rootDir: string, boostVersion: string): Promise<ApplicationInfo>;
+
+declare function auditTool(rootDir: string): Promise<AuditResult>;
+
+type DoctorCheckId = "config-present" | "config-valid" | "generated-with-drift" | "stack-detected" | "resources-fresh" | "agent-files-present" | "overrides-detected" | "hooks-wired" | "lint-strict";
+interface DoctorCheck {
+    id: DoctorCheckId;
+    status: "pass" | "warn" | "fail";
+    message: string;
+    details?: string[];
+}
+interface DoctorResult {
+    ok: boolean;
+    checks: DoctorCheck[];
+}
+declare function doctorTool(rootDir: string, boostVersion: string): Promise<DoctorResult>;
+
+declare function explainFindingTool(rule: string): {
+    ok: boolean;
+    error: string;
+    finding?: undefined;
+} | {
+    ok: boolean;
+    finding: ExplainEntry;
+    error?: undefined;
+};
+
+type RouteType = "page" | "layout" | "route-handler" | "error" | "loading" | "not-found" | "middleware" | "api-route";
+interface RouteEntry {
+    path: string;
+    type: RouteType;
+    file: string;
+    dynamic: string[];
+    slot?: string;
+}
+interface UnsupportedRoutes {
+    supported: false;
+    reason: string;
+}
+declare function listRoutesTool(rootDir: string): Promise<RouteEntry[] | UnsupportedRoutes>;
+
+declare const stackAdapters: StackAdapter[];
+declare function getStackAdapter(stack: DetectedStack): StackAdapter | null;
+
+export { type Agent, type AgentCapabilities, type AgentName, type ArchitectureConfigEntry, type ArchitectureSlug, type AuditFinding, type AuditResult, type DetectedStack, type DoctorCheck, type DoctorResult, type FeatureModulesBoundary, type FeatureName, type LintingKind, type NormalizedArchitecture, type PackageInfo, type PackageManagerInfo, type PackageManagerName, type ResourceSelection, type RouterKind, type StackAdapter, type StackName, applicationInfoTool, applyFileOperations, applyResourceOverrides, architectureEntrySchema, auditTool, buildInstallOperations, composeGuidelines, composeSkills, createNodeBoostJsonSchema, createNodeBoostMcpServer, detectNextRouter, detectPackageManager, detectStack, doctorTool, explainFinding, explainFindingTool, extractVersionFromRange, featureModulesBoundarySchema, getStackAdapter, listRoutesTool, nodeBoostConfigSchema, normalizeArchitectures, parseMajor, parseNodeBoostConfig, renderAgentReport, renderGuidelinesIndex, renderHumanReport, runAudit, runInstall, runUpdate, stackAdapters, startNodeBoostMcpServer };