@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { Command } from 'commander';
 import { ContextQLResult, IngestResult } from '@harness-engineering/graph';
-import { Result } from '@harness-engineering/core';
+import { Result, Violation } from '@harness-engineering/core';
 import { z } from 'zod';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
 interface Phase {
     name: string;
@@ -51,23 +52,40 @@ declare function runGraphStatus(projectPath: string): Promise<GraphStatusResult>
 declare function runGraphExport(projectPath: string, format: string): Promise<string>;
 
 /**
- * CLI Exit Codes
+ * Standard exit codes for the Harness CLI.
  */
 declare const ExitCode: {
+    /** Command completed successfully */
     readonly SUCCESS: 0;
+    /** Command failed because of a validation error (e.g. check-docs found issues) */
     readonly VALIDATION_FAILED: 1;
+    /** Command failed because of an unexpected error or misconfiguration */
     readonly ERROR: 2;
 };
+/**
+ * Type representing one of the supported exit codes.
+ */
 type ExitCodeType = (typeof ExitCode)[keyof typeof ExitCode];
 /**
- * CLI-specific error with exit code
+ * Custom error class for CLI-specific failures.
+ * Includes an exit code that should be used when terminating the process.
  */
 declare class CLIError extends Error {
+    /** The exit code associated with this error */
     readonly exitCode: ExitCodeType;
+    /**
+     * Creates a new CLIError.
+     *
+     * @param message - Human-readable error message.
+     * @param exitCode - Exit code to use when process terminates. Defaults to ExitCode.ERROR.
+     */
     constructor(message: string, exitCode?: ExitCodeType);
 }
 /**
- * Handle error and exit process
+ * Handles an error by logging it to stderr and exiting the process with the appropriate code.
+ *
+ * @param error - The error to handle.
+ * @throws Never returns, as it terminates the process.
  */
 declare function handleError(error: unknown): never;
 
@@ -142,59 +160,138 @@ declare function generateSlashCommands(opts: GenerateOptions): GenerateResult[];
 
 interface SkillSource {
     dir: string;
-    source: 'project' | 'global';
+    source: 'project' | 'community' | 'global';
 }
 
+/**
+ * Supported output modes for the CLI.
+ */
 declare const OutputMode: {
+    /** Output as formatted JSON */
     readonly JSON: "json";
+    /** Output as human-readable text */
     readonly TEXT: "text";
+    /** Minimal output, only errors and successes */
     readonly QUIET: "quiet";
+    /** Full output with detailed context and suggestions */
     readonly VERBOSE: "verbose";
 };
+/**
+ * Type representing one of the supported output modes.
+ */
 type OutputModeType = (typeof OutputMode)[keyof typeof OutputMode];
+/**
+ * Represents a single issue discovered during validation.
+ */
 interface ValidationIssue {
+    /** The file where the issue was found */
     file?: string;
+    /** A human-readable description of the issue */
     message: string;
+    /** The line number where the issue occurs */
     line?: number;
+    /** A suggested fix or next step */
     suggestion?: string;
 }
+/**
+ * The result of a validation operation.
+ */
 interface ValidationResult {
+    /** Whether the validation passed overall */
     valid: boolean;
+    /** A list of issues found during validation */
     issues: ValidationIssue[];
 }
+/**
+ * Formats data and results for CLI output based on the selected mode.
+ */
 declare class OutputFormatter {
     private mode;
+    /**
+     * Creates a new OutputFormatter.
+     *
+     * @param mode - The output mode to use. Defaults to TEXT.
+     */
     constructor(mode?: OutputModeType);
     /**
-     * Format raw data (for JSON mode)
+     * Formats raw data for output.
+     *
+     * @param data - The data to format.
+     * @returns A string representation of the data based on the current mode.
      */
     format(data: unknown): string;
     /**
-     * Format validation result
+     * Formats a validation result into a user-friendly string.
+     *
+     * @param result - The validation result to format.
+     * @returns A formatted string containing the validation status and any issues.
      */
     formatValidation(result: ValidationResult): string;
     /**
-     * Format a summary line
+     * Formats a summary line with a success/failure icon and label.
+     *
+     * @param label - The name of the field to summarize.
+     * @param value - The value to display.
+     * @param success - Whether the summary represents a success or failure state.
+     * @returns A formatted summary string, or an empty string in JSON or QUIET modes.
      */
     formatSummary(label: string, value: string | number, success: boolean): string;
 }
 
+/**
+ * Simple logger for CLI output with color-coded icons.
+ */
 declare const logger: {
+    /**
+     * Logs an informational message with a blue 'i' icon.
+     * @param message - The message to log.
+     */
     info: (message: string) => void;
+    /**
+     * Logs a success message with a green 'v' icon.
+     * @param message - The message to log.
+     */
     success: (message: string) => void;
+    /**
+     * Logs a warning message with a yellow '!' icon.
+     * @param message - The message to log.
+     */
     warn: (message: string) => void;
+    /**
+     * Logs an error message with a red 'x' icon to stderr.
+     * @param message - The message to log.
+     */
     error: (message: string) => void;
+    /**
+     * Logs a dimmed message.
+     * @param message - The message to log.
+     */
     dim: (message: string) => void;
+    /**
+     * Logs raw data as a formatted JSON string.
+     * Useful for JSON output mode.
+     * @param data - The data to log.
+     */
     raw: (data: unknown) => void;
 };
 
+/**
+ * The main Harness configuration schema.
+ */
 declare const HarnessConfigSchema: z.ZodObject<{
+    /** Configuration schema version */
     version: z.ZodLiteral<1>;
+    /** Human-readable name of the project */
     name: z.ZodOptional<z.ZodString>;
+    /** Root directory of the project, relative to the config file */
     rootDir: z.ZodDefault<z.ZodString>;
+    /** Layered architecture definitions */
     layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Human-readable name of the layer */
         name: z.ZodString;
+        /** Glob pattern matching files in this layer */
         pattern: z.ZodString;
+        /** Names of other layers this layer is allowed to import from */
         allowedDependencies: z.ZodArray<z.ZodString, "many">;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -205,9 +302,13 @@ declare const HarnessConfigSchema: z.ZodObject<{
         pattern: string;
         allowedDependencies: string[];
     }>, "many">>;
+    /** Rules for forbidden cross-module imports */
     forbiddenImports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Glob pattern matching source files this rule applies to */
         from: z.ZodString;
+        /** List of modules or patterns that are not allowed to be imported */
         disallow: z.ZodArray<z.ZodString, "many">;
+        /** Optional custom message to display on violation */
         message: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         from: string;
@@ -218,18 +319,26 @@ declare const HarnessConfigSchema: z.ZodObject<{
         disallow: string[];
         message?: string | undefined;
     }>, "many">>;
+    /** Boundary enforcement settings */
     boundaries: z.ZodOptional<z.ZodObject<{
+        /** List of globs where files MUST have a corresponding schema/definition */
         requireSchema: z.ZodArray<z.ZodString, "many">;
     }, "strip", z.ZodTypeAny, {
         requireSchema: string[];
     }, {
         requireSchema: string[];
     }>>;
+    /** Path to the project's knowledge map (AGENTS.md) */
     agentsMapPath: z.ZodDefault<z.ZodString>;
+    /** Directory containing project documentation */
     docsDir: z.ZodDefault<z.ZodString>;
+    /** Agent orchestration settings */
     agent: z.ZodOptional<z.ZodObject<{
+        /** The execution environment for agents */
         executor: z.ZodDefault<z.ZodEnum<["subprocess", "cloud", "noop"]>>;
+        /** Maximum execution time in milliseconds */
         timeout: z.ZodDefault<z.ZodNumber>;
+        /** Optional list of skill IDs pre-authorized for the agent */
         skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         executor: "subprocess" | "cloud" | "noop";
@@ -240,8 +349,11 @@ declare const HarnessConfigSchema: z.ZodObject<{
         timeout?: number | undefined;
         skills?: string[] | undefined;
     }>>;
+    /** Drift and stale code management settings */
     entropy: z.ZodOptional<z.ZodObject<{
+        /** Patterns to exclude from entropy analysis */
         excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Whether to automatically attempt to fix simple entropy issues */
         autoFix: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         excludePatterns: string[];
@@ -250,38 +362,65 @@ declare const HarnessConfigSchema: z.ZodObject<{
         excludePatterns?: string[] | undefined;
         autoFix?: boolean | undefined;
     }>>;
+    /** Security scanning configuration */
     security: z.ZodOptional<z.ZodObject<{
+        /** Whether security scanning is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to fail on any security warning */
         strict: z.ZodDefault<z.ZodBoolean>;
+        /** Rule-specific severity overrides */
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["off", "error", "warning", "info"]>>>;
+        /** Patterns to exclude from security scans */
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** Whether security scanning is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to fail on any security warning */
         strict: z.ZodDefault<z.ZodBoolean>;
+        /** Rule-specific severity overrides */
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["off", "error", "warning", "info"]>>>;
+        /** Patterns to exclude from security scans */
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** Whether security scanning is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to fail on any security warning */
         strict: z.ZodDefault<z.ZodBoolean>;
+        /** Rule-specific severity overrides */
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["off", "error", "warning", "info"]>>>;
+        /** Patterns to exclude from security scans */
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">>>;
+    /** Performance and complexity budget settings */
     performance: z.ZodOptional<z.ZodObject<{
+        /** Complexity thresholds per module or pattern */
         complexity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Coupling limits between modules */
         coupling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Size budget for bundles or directories */
         sizeBudget: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** Complexity thresholds per module or pattern */
         complexity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Coupling limits between modules */
         coupling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Size budget for bundles or directories */
         sizeBudget: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** Complexity thresholds per module or pattern */
         complexity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Coupling limits between modules */
         coupling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Size budget for bundles or directories */
         sizeBudget: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.ZodTypeAny, "passthrough">>>;
+    /** Project template settings (used by 'harness init') */
     template: z.ZodOptional<z.ZodObject<{
+        /** Complexity level of the template */
         level: z.ZodEnum<["basic", "intermediate", "advanced"]>;
+        /** Primary technology framework */
         framework: z.ZodOptional<z.ZodString>;
+        /** Template version */
         version: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         version: number;
@@ -292,11 +431,17 @@ declare const HarnessConfigSchema: z.ZodObject<{
         level: "basic" | "intermediate" | "advanced";
         framework?: string | undefined;
     }>>;
+    /** Phase gate and readiness check configuration */
     phaseGates: z.ZodOptional<z.ZodObject<{
+        /** Whether phase gate checks are enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Severity level when a phase gate check fails */
         severity: z.ZodDefault<z.ZodEnum<["error", "warning"]>>;
+        /** List of implementation-to-spec mappings */
         mappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Pattern for implementation files */
             implPattern: z.ZodString;
+            /** Pattern for corresponding specification files */
             specPattern: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             implPattern: string;
@@ -320,10 +465,15 @@ declare const HarnessConfigSchema: z.ZodObject<{
             specPattern: string;
         }[] | undefined;
     }>>;
+    /** Design system consistency settings */
     design: z.ZodOptional<z.ZodObject<{
+        /** Strictness of design system enforcement */
         strictness: z.ZodDefault<z.ZodEnum<["strict", "standard", "permissive"]>>;
+        /** Supported target platforms */
         platforms: z.ZodDefault<z.ZodArray<z.ZodEnum<["web", "mobile"]>, "many">>;
+        /** Path to design tokens (e.g. JSON or CSS) */
         tokenPath: z.ZodOptional<z.ZodString>;
+        /** Brief description of the intended aesthetic direction */
         aestheticIntent: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         strictness: "strict" | "standard" | "permissive";
@@ -336,21 +486,37 @@ declare const HarnessConfigSchema: z.ZodObject<{
         tokenPath?: string | undefined;
         aestheticIntent?: string | undefined;
     }>>;
+    /** Internationalization (i18n) settings */
     i18n: z.ZodOptional<z.ZodObject<{
+        /** Whether i18n management is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Strictness of i18n rule enforcement */
         strictness: z.ZodDefault<z.ZodEnum<["strict", "standard", "permissive"]>>;
+        /** The primary language used for development */
         sourceLocale: z.ZodDefault<z.ZodString>;
+        /** List of locales that translations are required for */
         targetLocales: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The i18n framework in use */
         framework: z.ZodDefault<z.ZodEnum<["auto", "i18next", "react-intl", "vue-i18n", "flutter-intl", "apple", "android", "custom"]>>;
+        /** Storage format for translation files */
         format: z.ZodDefault<z.ZodString>;
+        /** Syntax used for message formatting */
         messageFormat: z.ZodDefault<z.ZodEnum<["icu", "i18next", "custom"]>>;
+        /** Convention for translation keys */
         keyConvention: z.ZodDefault<z.ZodEnum<["dot-notation", "snake_case", "camelCase", "custom"]>>;
+        /** Mapping of locales to their file paths */
         translationPaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Platforms targeted by this configuration */
         platforms: z.ZodDefault<z.ZodArray<z.ZodEnum<["web", "mobile", "backend"]>, "many">>;
+        /** Industry vertical (for contextual translations) */
         industry: z.ZodOptional<z.ZodString>;
+        /** Translation coverage requirements */
         coverage: z.ZodOptional<z.ZodObject<{
+            /** Minimum required translation percentage */
             minimumPercent: z.ZodDefault<z.ZodNumber>;
+            /** Whether plural forms are required for all keys */
             requirePlurals: z.ZodDefault<z.ZodBoolean>;
+            /** Whether to detect untranslated strings in source code */
             detectUntranslated: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             minimumPercent: number;
@@ -361,9 +527,13 @@ declare const HarnessConfigSchema: z.ZodObject<{
             requirePlurals?: boolean | undefined;
             detectUntranslated?: boolean | undefined;
         }>>;
+        /** Locale used for pseudo-localization testing */
         pseudoLocale: z.ZodOptional<z.ZodString>;
+        /** MCP server for AI-assisted translation */
         mcp: z.ZodOptional<z.ZodObject<{
+            /** Name or URL of the MCP server */
             server: z.ZodString;
+            /** Project ID on the remote i18n platform */
             projectId: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             server: string;
@@ -417,10 +587,15 @@ declare const HarnessConfigSchema: z.ZodObject<{
             projectId?: string | undefined;
         } | undefined;
     }>>;
+    /** Code review settings */
     review: z.ZodOptional<z.ZodObject<{
+        /** Custom model tier mappings for reviewers */
         model_tiers: z.ZodOptional<z.ZodObject<{
+            /** Model ID to use for fast/cheap operations */
             fast: z.ZodOptional<z.ZodString>;
+            /** Model ID to use for standard reasoning tasks */
             standard: z.ZodOptional<z.ZodString>;
+            /** Model ID to use for complex/critical analysis */
             strong: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             standard?: string | undefined;
@@ -444,6 +619,24 @@ declare const HarnessConfigSchema: z.ZodObject<{
             strong?: string | undefined;
         } | undefined;
     }>>;
+    /** General architectural enforcement settings */
+    architecture: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        baselinePath: z.ZodDefault<z.ZodString>;
+        thresholds: z.ZodDefault<z.ZodRecord<z.ZodEnum<["circular-deps", "layer-violations", "complexity", "coupling", "forbidden-imports", "module-size", "dependency-depth"]>, z.ZodUnion<[z.ZodNumber, z.ZodRecord<z.ZodString, z.ZodNumber>]>>>;
+        modules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<["circular-deps", "layer-violations", "complexity", "coupling", "forbidden-imports", "module-size", "dependency-depth"]>, z.ZodUnion<[z.ZodNumber, z.ZodRecord<z.ZodString, z.ZodNumber>]>>>>;
+    }, "strip", z.ZodTypeAny, {
+        thresholds: Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>;
+        modules: Record<string, Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>>;
+        enabled: boolean;
+        baselinePath: string;
+    }, {
+        thresholds?: Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>> | undefined;
+        modules?: Record<string, Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>> | undefined;
+        enabled?: boolean | undefined;
+        baselinePath?: string | undefined;
+    }>>;
+    /** How often (in ms) to check for CLI updates */
     updateCheckInterval: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
@@ -474,14 +667,21 @@ declare const HarnessConfigSchema: z.ZodObject<{
         autoFix: boolean;
     } | undefined;
     security?: z.objectOutputType<{
+        /** Whether security scanning is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to fail on any security warning */
         strict: z.ZodDefault<z.ZodBoolean>;
+        /** Rule-specific severity overrides */
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["off", "error", "warning", "info"]>>>;
+        /** Patterns to exclude from security scans */
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     performance?: z.objectOutputType<{
+        /** Complexity thresholds per module or pattern */
         complexity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Coupling limits between modules */
         coupling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Size budget for bundles or directories */
         sizeBudget: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     template?: {
@@ -533,6 +733,12 @@ declare const HarnessConfigSchema: z.ZodObject<{
             strong?: string | undefined;
         } | undefined;
     } | undefined;
+    architecture?: {
+        thresholds: Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>;
+        modules: Record<string, Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>>;
+        enabled: boolean;
+        baselinePath: string;
+    } | undefined;
     updateCheckInterval?: number | undefined;
 }, {
     version: 1;
@@ -563,14 +769,21 @@ declare const HarnessConfigSchema: z.ZodObject<{
         autoFix?: boolean | undefined;
     } | undefined;
     security?: z.objectInputType<{
+        /** Whether security scanning is enabled */
         enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to fail on any security warning */
         strict: z.ZodDefault<z.ZodBoolean>;
+        /** Rule-specific severity overrides */
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["off", "error", "warning", "info"]>>>;
+        /** Patterns to exclude from security scans */
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     performance?: z.objectInputType<{
+        /** Complexity thresholds per module or pattern */
         complexity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Coupling limits between modules */
         coupling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Size budget for bundles or directories */
         sizeBudget: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     template?: {
@@ -622,20 +835,40 @@ declare const HarnessConfigSchema: z.ZodObject<{
             strong?: string | undefined;
         } | undefined;
     } | undefined;
+    architecture?: {
+        thresholds?: Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>> | undefined;
+        modules?: Record<string, Partial<Record<"complexity" | "coupling" | "circular-deps" | "layer-violations" | "forbidden-imports" | "module-size" | "dependency-depth", number | Record<string, number>>>> | undefined;
+        enabled?: boolean | undefined;
+        baselinePath?: string | undefined;
+    } | undefined;
     updateCheckInterval?: number | undefined;
 }>;
+/**
+ * Type representing the full Harness configuration.
+ */
 type HarnessConfig = z.infer<typeof HarnessConfigSchema>;
 
 /**
- * Find config file starting from given directory
+ * Searches for a Harness configuration file starting from the given directory
+ * and moving up the directory tree until the root is reached.
+ *
+ * @param startDir - The directory to start searching from. Defaults to current working directory.
+ * @returns An Ok result containing the absolute path to the config file, or an Err with a CLIError if not found.
  */
 declare function findConfigFile(startDir?: string): Result<string, CLIError>;
 /**
- * Load and validate config from file
+ * Loads and validates a Harness configuration from a JSON file.
+ *
+ * @param configPath - The path to the configuration file.
+ * @returns An Ok result with the validated HarnessConfig, or an Err with a CLIError if loading or validation fails.
  */
 declare function loadConfig(configPath: string): Result<HarnessConfig, CLIError>;
 /**
- * Load config from default location or specified path
+ * Resolves the Harness configuration by either loading from a specified path
+ * or searching for the default config file in the current directory tree.
+ *
+ * @param configPath - Optional path to a specific configuration file.
+ * @returns An Ok result with the resolved configuration, or an Err with a CLIError.
  */
 declare function resolveConfig(configPath?: string): Result<HarnessConfig, CLIError>;
 
@@ -987,6 +1220,89 @@ declare function renderClaudeCodeAgent(def: AgentDefinition): string;
 
 declare function renderGeminiAgent(def: AgentDefinition): string;
 
+interface ImpactPreviewOptions {
+    detailed?: boolean;
+    perFile?: boolean;
+    path?: string;
+}
+declare function runImpactPreview(options: ImpactPreviewOptions): Promise<string>;
+
+interface CheckArchOptions {
+    cwd?: string;
+    configPath?: string;
+    updateBaseline?: boolean;
+    json?: boolean;
+    module?: string;
+}
+interface CheckArchResult {
+    passed: boolean;
+    mode: 'baseline' | 'threshold-only';
+    totalViolations: number;
+    newViolations: Violation[];
+    resolvedViolations: string[];
+    preExisting: string[];
+    regressions: Array<{
+        category: string;
+        baselineValue: number;
+        currentValue: number;
+        delta: number;
+    }>;
+    thresholdViolations: Violation[];
+    baselineUpdated?: boolean;
+    warning?: string;
+}
+declare function runCheckArch(options: CheckArchOptions): Promise<Result<CheckArchResult, CLIError>>;
+
+type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+declare function getToolDefinitions(): ToolDefinition[];
+declare function createHarnessServer(projectRoot?: string): Server;
+declare function startServer(): Promise<void>;
+
+interface InstallOptions {
+    version?: string;
+    force?: boolean;
+}
+interface InstallResult {
+    installed: boolean;
+    skipped?: boolean;
+    upgraded?: boolean;
+    name: string;
+    version: string;
+    previousVersion?: string;
+    warnings?: string[];
+}
+declare function runInstall(skillName: string, options: InstallOptions): Promise<InstallResult>;
+
+interface UninstallOptions {
+    force?: boolean;
+}
+interface UninstallResult {
+    removed: boolean;
+    name: string;
+    version: string;
+    warnings?: string[];
+}
+declare function runUninstall(skillName: string, options: UninstallOptions): Promise<UninstallResult>;
+
+/**
+ * @harness-engineering/cli
+ *
+ * Command-line interface for the Harness Engineering toolkit.
+ *
+ * This package provides a unified `harness` command with subcommands for
+ * validation, documentation management, dependency checking, and agent
+ * orchestration.
+ */
+
+/**
+ * Creates and configures the main Harness CLI program.
+ *
+ * @returns A Commander instance with all subcommands registered.
+ */
 declare function createProgram(): Command;
 
-export { AGENT_DESCRIPTIONS, ALLOWED_PERSONA_COMMANDS, type AgentDefinition, CLIError, type CommandExecutor, type CommandStep, type CreateSkillOptions, DEFAULT_TOOLS, ExitCode, GEMINI_TOOL_MAP, type GenerateAgentDefsOptions, type GenerateAgentDefsResult, type GenerateResult, type HandoffContext, type HarnessConfig, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type SkillExecutionContext, type SkillExecutionResult, type SkillExecutor, type SkillSource, type SkillStep, type Step, type StepExecutionContext, type StepReport, type TemplateContext, TemplateEngine, type TriggerContext, type TriggerDetectionResult, buildPreamble, createProgram, detectTrigger, executeSkill, findConfigFile, generateAgentDefinition, generateAgentDefinitions, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, generateSlashCommands, handleError, listPersonas, loadConfig, loadPersona, logger, renderClaudeCodeAgent, renderGeminiAgent, resolveConfig, runCheckPhaseGate, runCrossCheck, runGraphExport, runGraphStatus, runIngest, runPersona, runQuery, runScan };
+export { AGENT_DESCRIPTIONS, ALLOWED_PERSONA_COMMANDS, type AgentDefinition, CLIError, type CheckArchResult, type CommandExecutor, type CommandStep, type CreateSkillOptions, DEFAULT_TOOLS, ExitCode, GEMINI_TOOL_MAP, type GenerateAgentDefsOptions, type GenerateAgentDefsResult, type GenerateResult, type HandoffContext, type HarnessConfig, type InstallResult, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type SkillExecutionContext, type SkillExecutionResult, type SkillExecutor, type SkillSource, type SkillStep, type Step, type StepExecutionContext, type StepReport, type TemplateContext, TemplateEngine, type TriggerContext, type TriggerDetectionResult, type UninstallResult, buildPreamble, createHarnessServer, createProgram, detectTrigger, executeSkill, findConfigFile, generateAgentDefinition, generateAgentDefinitions, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, generateSlashCommands, getToolDefinitions, handleError, listPersonas, loadConfig, loadPersona, logger, renderClaudeCodeAgent, renderGeminiAgent, resolveConfig, runCheckArch, runCheckPhaseGate, runCrossCheck, runGraphExport, runGraphStatus, runImpactPreview, runIngest, runInstall, runPersona, runQuery, runScan, runUninstall, startServer };