@levironexe/architect 0.1.0

package/dist/types/analysis.d.ts

@@ -0,0 +1,130 @@
+export declare const DEFAULT_LOC_THRESHOLD = 300;
+export declare const DEFAULT_COMPLEXITY_THRESHOLD = 15;
+export declare const SUPPORTED_EXTENSIONS: readonly [".js", ".jsx", ".ts", ".tsx"];
+export declare const ALWAYS_EXCLUDED_DIRS: readonly ["node_modules", ".git", "dist", "build"];
+export type SupportedExtension = (typeof SUPPORTED_EXTENSIONS)[number];
+export interface FunctionInfo {
+    name: string;
+    paramCount: number;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    complexity: number;
+    isFlagged: boolean;
+}
+export interface ClassInfo {
+    name: string;
+    startLine: number;
+    endLine: number;
+    methodCount: number;
+}
+export interface ImportInfo {
+    source: string;
+    isRelative: boolean;
+    isBuiltin: boolean;
+    specifiers: string[];
+}
+export interface ExportInfo {
+    name: string;
+    kind: 'named' | 'default' | 'all';
+}
+export interface FileAnalysis {
+    path: string;
+    relativePath: string;
+    loc: number;
+    blankLines: number;
+    commentLines: number;
+    totalLines: number;
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    isOversized: boolean;
+    hasCriticalComplexity: boolean;
+    parseError: string | null;
+}
+export interface ParseError {
+    path: string;
+    relativePath: string;
+    error: string;
+}
+export interface DependencyNode {
+    path: string;
+    relativePath: string;
+    imports: string[];
+    importedBy: string[];
+}
+export interface CircularDependencyChain {
+    files: string[];
+}
+export interface DependencyHotspot {
+    relativePath: string;
+    dependentCount: number;
+}
+export interface DependencyGraphSummary {
+    nodes: DependencyNode[];
+    circularDependencies: CircularDependencyChain[];
+    hotspots: DependencyHotspot[];
+    unreferencedFiles: string[];
+    isPartial: boolean;
+}
+export interface DuplicationOccurrence {
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+}
+export interface DuplicationFinding {
+    occurrences: DuplicationOccurrence[];
+    duplicatedLines: number;
+    similarity: number | null;
+}
+export interface DuplicationSummary {
+    findings: DuplicationFinding[];
+    duplicatedLines: number;
+    duplicationPercentage: number;
+    isPartial: boolean;
+}
+export interface ScanSummary {
+    targetDir: string;
+    totalFiles: number;
+    skippedFiles: number;
+    totalLoc: number;
+    totalLines: number;
+    flaggedFiles: number;
+    flaggedFunctions: number;
+    dependencyHotspots: number;
+    circularDependencies: number;
+    duplicateFindings: number;
+    duplicatedLines: number;
+    scanDurationMs: number;
+}
+import type { ScoreBreakdown } from './scoring.js';
+import type { SkillMatch, SkillWarning, StructureComparison } from './skill.js';
+import type { ReportGuidance, ReportIssue } from './issue.js';
+import type { ScanDiagnostic, ScanWarning, SkippedInput } from './scan-output.js';
+export interface ScanResult {
+    summary: ScanSummary;
+    files: FileAnalysis[];
+    parseErrors: ParseError[];
+    dependencyGraph: DependencyGraphSummary;
+    duplication: DuplicationSummary;
+    skillLoadWarnings?: SkillWarning[];
+    matchedSkills?: SkillMatch[];
+    structureComparison?: StructureComparison | null;
+    scores?: ScoreBreakdown;
+    issues?: ReportIssue[];
+    guidance?: ReportGuidance;
+    warnings?: ScanWarning[];
+    diagnostics?: ScanDiagnostic[];
+    skippedInputs?: SkippedInput[];
+}
+export interface ScanOptions {
+    cwd?: string;
+    color?: boolean;
+    locThreshold?: number;
+    complexityThreshold?: number;
+}
+export declare function createEmptySummary(targetDir: string): ScanSummary;
+export declare function createEmptyDependencyGraphSummary(isPartial?: boolean): DependencyGraphSummary;
+export declare function createEmptyDuplicationSummary(isPartial?: boolean): DuplicationSummary;
+export declare function isSupportedExtension(filePath: string): boolean;

package/dist/types/analysis.js

@@ -0,0 +1,41 @@
+export const DEFAULT_LOC_THRESHOLD = 300;
+export const DEFAULT_COMPLEXITY_THRESHOLD = 15;
+export const SUPPORTED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
+export const ALWAYS_EXCLUDED_DIRS = ['node_modules', '.git', 'dist', 'build'];
+export function createEmptySummary(targetDir) {
+    return {
+        targetDir,
+        totalFiles: 0,
+        skippedFiles: 0,
+        totalLoc: 0,
+        totalLines: 0,
+        flaggedFiles: 0,
+        flaggedFunctions: 0,
+        dependencyHotspots: 0,
+        circularDependencies: 0,
+        duplicateFindings: 0,
+        duplicatedLines: 0,
+        scanDurationMs: 0
+    };
+}
+export function createEmptyDependencyGraphSummary(isPartial = false) {
+    return {
+        nodes: [],
+        circularDependencies: [],
+        hotspots: [],
+        unreferencedFiles: [],
+        isPartial
+    };
+}
+export function createEmptyDuplicationSummary(isPartial = false) {
+    return {
+        findings: [],
+        duplicatedLines: 0,
+        duplicationPercentage: 0,
+        isPartial
+    };
+}
+export function isSupportedExtension(filePath) {
+    return SUPPORTED_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+//# sourceMappingURL=analysis.js.map

package/dist/types/analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.js","sourceRoot":"","sources":["../../src/types/analysis.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AACzC,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,CAAC;AAE/C,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAU,CAAC;AAC5E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AA8IvF,MAAM,UAAU,kBAAkB,CAAC,SAAiB;IAClD,OAAO;QACL,SAAS;QACT,UAAU,EAAE,CAAC;QACb,YAAY,EAAE,CAAC;QACf,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,CAAC;QACb,YAAY,EAAE,CAAC;QACf,gBAAgB,EAAE,CAAC;QACnB,kBAAkB,EAAE,CAAC;QACrB,oBAAoB,EAAE,CAAC;QACvB,iBAAiB,EAAE,CAAC;QACpB,eAAe,EAAE,CAAC;QAClB,cAAc,EAAE,CAAC;KAClB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,iCAAiC,CAAC,SAAS,GAAG,KAAK;IACjE,OAAO;QACL,KAAK,EAAE,EAAE;QACT,oBAAoB,EAAE,EAAE;QACxB,QAAQ,EAAE,EAAE;QACZ,iBAAiB,EAAE,EAAE;QACrB,SAAS;KACV,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAC,SAAS,GAAG,KAAK;IAC7D,OAAO;QACL,QAAQ,EAAE,EAAE;QACZ,eAAe,EAAE,CAAC;QAClB,qBAAqB,EAAE,CAAC;QACxB,SAAS;KACV,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACnD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;AAChF,CAAC"}

package/dist/types/concern.d.ts

@@ -0,0 +1,48 @@
+import type { ImportInfo } from './analysis.js';
+import type { SeparationRule } from './skill.js';
+export declare const CONCERN_TYPES: readonly ["routing", "business_logic", "data_access", "validation", "middleware", "ui_component", "utility", "configuration", "test", "unclassified"];
+export type ConcernType = (typeof CONCERN_TYPES)[number];
+export type ClassificationMode = 'completed' | 'skipped' | 'partial' | 'failed';
+export interface FunctionSignatureSummary {
+    name: string;
+    paramCount: number;
+    startLine: number;
+    endLine: number;
+}
+export interface FileClassificationInput {
+    relativePath: string;
+    imports: ImportInfo[];
+    functions: FunctionSignatureSummary[];
+}
+export interface ClassificationSkillContext {
+    id: string;
+    name: string;
+    separationRules: SeparationRule[];
+}
+export interface ClassificationRequest {
+    projectRoot: string;
+    skill: ClassificationSkillContext | null;
+    files: FileClassificationInput[];
+    tokenBudget: number;
+}
+export interface FunctionConcernClassification {
+    name: string;
+    concern: ConcernType;
+    confidence: number;
+    isMisplaced: boolean;
+    reason?: string;
+}
+export interface ConcernClassification {
+    file: string;
+    functions: FunctionConcernClassification[];
+    dominantConcern: ConcernType;
+    mixedConcerns: boolean;
+    warnings: string[];
+}
+export interface ClassificationStatus {
+    mode: ClassificationMode;
+    provider?: string;
+    reason?: string;
+    warnings: string[];
+}
+export declare function isConcernType(value: string): value is ConcernType;

package/dist/types/concern.js

@@ -0,0 +1,16 @@
+export const CONCERN_TYPES = [
+    'routing',
+    'business_logic',
+    'data_access',
+    'validation',
+    'middleware',
+    'ui_component',
+    'utility',
+    'configuration',
+    'test',
+    'unclassified'
+];
+export function isConcernType(value) {
+    return CONCERN_TYPES.includes(value);
+}
+//# sourceMappingURL=concern.js.map

package/dist/types/concern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concern.js","sourceRoot":"","sources":["../../src/types/concern.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,SAAS;IACT,gBAAgB;IAChB,aAAa;IACb,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,SAAS;IACT,eAAe;IACf,MAAM;IACN,cAAc;CACN,CAAC;AAsDX,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,aAAa,CAAC,QAAQ,CAAC,KAAoB,CAAC,CAAC;AACtD,CAAC"}

package/dist/types/generation.d.ts

@@ -0,0 +1,32 @@
+export interface TemplateContext {
+    skill: {
+        id: string;
+        name: string;
+        structure: {
+            required: string;
+        };
+        separation: {
+            data_flow: string;
+            rules: string;
+        };
+        anti_patterns: string;
+    };
+    analysis: {
+        largestFiles: string;
+        hubFiles: string;
+        duplicationPercent: string;
+        missingDirs: string;
+    };
+}
+export interface RenderedSkillFile {
+    name: string;
+    content: string;
+}
+export interface InitSummary {
+    targetDir: string;
+    skillId: string;
+    integration: string;
+    filesWritten: string[];
+    filesSkipped: string[];
+    warnings: string[];
+}

package/dist/types/generation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generation.js.map

package/dist/types/generation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation.js","sourceRoot":"","sources":["../../src/types/generation.ts"],"names":[],"mappings":""}

package/dist/types/issue.d.ts

@@ -0,0 +1,12 @@
+export type IssueSeverity = 'critical' | 'warning' | 'info';
+export interface ReportIssue {
+    severity: IssueSeverity;
+    category: string;
+    location?: string;
+    message: string;
+    suggestion: string;
+}
+export interface ReportGuidance {
+    message: string;
+    command?: string;
+}

package/dist/types/issue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=issue.js.map

package/dist/types/issue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue.js","sourceRoot":"","sources":["../../src/types/issue.ts"],"names":[],"mappings":""}

package/dist/types/pattern.d.ts

@@ -0,0 +1,15 @@
+import type { ConcernType } from './concern.js';
+export type PatternConfidence = 'high' | 'medium' | 'low' | 'insufficient';
+export interface PatternDeviation {
+    location: string;
+    pattern: string;
+    expectedPattern: string;
+}
+export interface PatternFinding {
+    concern: ConcernType;
+    dominantPattern: string | null;
+    patternCount: number;
+    deviations: PatternDeviation[];
+    confidence: PatternConfidence;
+    reason: string;
+}

package/dist/types/pattern.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pattern.js.map

package/dist/types/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../src/types/pattern.ts"],"names":[],"mappings":""}

package/dist/types/plan.d.ts

@@ -0,0 +1,56 @@
+import type { ScanResult } from './analysis.js';
+import type { SkillMatch } from './skill.js';
+export type PlanRisk = 'low' | 'medium' | 'high';
+export type PlanComplexity = 'low' | 'medium' | 'high';
+export type RefactorAction = 'create_dir' | 'extract' | 'move' | 'consolidate' | 'delete' | 'update_imports';
+export type PlanValidationSeverity = 'warning' | 'error';
+export type PlanOutputFormat = 'terminal' | 'md' | 'json' | 'prompt';
+export interface RefactorPlan {
+    summary: string;
+    estimatedComplexity: PlanComplexity;
+    estimatedRisk: PlanRisk;
+    phases: PlanPhase[];
+    validationFindings: PlanValidationFinding[];
+    assumptions: string[];
+    source: {
+        targetDir: string;
+        primarySkillId: string | null;
+        healthLabel: string;
+        issueCount: number;
+    };
+}
+export interface PlanPhase {
+    name: string;
+    description: string;
+    steps: RefactorStep[];
+}
+export interface RefactorStep {
+    stepNumber: number;
+    action: RefactorAction;
+    sourceFile: string | null;
+    targetFile: string;
+    what: string;
+    why: string;
+    lineRange: string | null;
+    importsToUpdate: string[];
+    dependencyNotes: string;
+    risk: PlanRisk;
+    confidence: 'low' | 'medium' | 'high';
+}
+export interface PlanValidationFinding {
+    severity: PlanValidationSeverity;
+    stepNumber: number | null;
+    message: string;
+    suggestion: string;
+}
+export interface PlanGenerationContext {
+    scan: ScanResult;
+    primarySkill: SkillMatch | null;
+}
+export interface AIAgentPrompt {
+    projectContext: string;
+    skillBlueprint: string;
+    plan: string;
+    constraints: string[];
+    budgetStatus: 'within_budget' | 'trimmed';
+}

package/dist/types/plan.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plan.js.map

package/dist/types/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../src/types/plan.ts"],"names":[],"mappings":""}

package/dist/types/scan-output.d.ts

@@ -0,0 +1,84 @@
+import type { ScanResult } from './analysis.js';
+export type ScanRunStatus = 'success' | 'partial' | 'failed';
+export type ScanOutputMode = 'terminal' | 'json';
+export type SkippedInputReason = 'unsupported_type' | 'binary' | 'parse_error' | 'ignored' | 'unreadable' | 'outside_target';
+export type QualityObservationType = 'bug' | 'threshold_tuning' | 'message_tuning' | 'plan_quality' | 'note';
+export type QualityObservationSeverity = 'low' | 'medium' | 'high';
+export interface ScanThresholds {
+    locThreshold: number;
+    complexityThreshold: number;
+}
+export interface ThresholdConfiguration extends ScanThresholds {
+    source: 'default' | 'cli';
+}
+export interface ScanWarning {
+    code: string;
+    message: string;
+    path?: string;
+}
+export interface ScanDiagnostic {
+    phase: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface SkippedInput {
+    path: string;
+    reason: SkippedInputReason;
+    message: string;
+    affectsConfidence: boolean;
+}
+export interface ScanRun {
+    targetDir: string;
+    status: ScanRunStatus;
+    outputMode: ScanOutputMode;
+    verbose: boolean;
+    startedAt: string;
+    durationMs: number;
+    warnings: ScanWarning[];
+    diagnostics: ScanDiagnostic[];
+    result: ScanResult | null;
+}
+export interface MetricsOnlyResult {
+    availableDimensions: string[];
+    unavailableDimensions: Array<{
+        id: string;
+        reason: string;
+    }>;
+    healthState: string;
+    classificationStatus: string;
+}
+export interface MachineReadableScanOutput {
+    schemaVersion: '1.0';
+    command: {
+        name: 'scan';
+        targetDir: string;
+        verbose: boolean;
+    };
+    run: {
+        status: ScanRunStatus;
+        durationMs: number;
+        outputMode: 'json';
+    };
+    result: ScanResult | null;
+    warnings: ScanWarning[];
+    diagnostics: ScanDiagnostic[];
+    error?: {
+        message: string;
+        correctiveAction: string;
+    };
+}
+export interface IntegrationSample {
+    name: string;
+    category: string;
+    source: string;
+    commandsRun: string[];
+    outcome: 'pass' | 'partial' | 'blocked';
+    observations: QualityObservation[];
+}
+export interface QualityObservation {
+    sampleName: string;
+    type: QualityObservationType;
+    severity: QualityObservationSeverity;
+    description: string;
+    followUp: string;
+}

package/dist/types/scan-output.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scan-output.js.map

package/dist/types/scan-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-output.js","sourceRoot":"","sources":["../../src/types/scan-output.ts"],"names":[],"mappings":""}

package/dist/types/scoring.d.ts

@@ -0,0 +1,15 @@
+export type ScoreLabel = 'healthy' | 'warning' | 'critical';
+export type HealthLabel = ScoreLabel | 'unavailable';
+export type ScoreDimensionId = 'modularity' | 'duplication';
+export interface DimensionScore {
+    score: number;
+    weight: number;
+    label: ScoreLabel;
+    reasons: string[];
+}
+export interface ScoreBreakdown {
+    modularity: DimensionScore;
+    duplication: DimensionScore;
+    overall: number;
+    label: HealthLabel;
+}

package/dist/types/scoring.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scoring.js.map

package/dist/types/scoring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.js","sourceRoot":"","sources":["../../src/types/scoring.ts"],"names":[],"mappings":""}

package/dist/types/skill.d.ts

@@ -0,0 +1,97 @@
+export declare const SUPPORTED_SKILL_SCHEMA_VERSION = "2.0.0";
+export type SkillCategory = 'stack' | 'pattern' | 'meta';
+export type SkillConfidence = 'high' | 'medium' | 'low';
+export type IssueSeverity = 'info' | 'warning' | 'critical';
+export interface ArchitectureSkill {
+    schemaVersion: string;
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    category: SkillCategory;
+    language: string;
+    frameworks: string[];
+    detection: DetectionRules;
+    structure: TargetStructure;
+    separation: SeparationRules;
+    patterns: PatternRules;
+    antiPatterns: AntiPattern[];
+}
+export interface DetectionRules {
+    dependencies?: {
+        any?: string[];
+        all?: string[];
+        none?: string[];
+    };
+    files?: string[];
+    sourceIndicators?: string[];
+}
+export interface TargetStructure {
+    requiredDirs: StructureEntry[];
+    recommendedDirs: StructureEntry[];
+}
+export interface StructureEntry {
+    path: string;
+    purpose: string;
+}
+export interface SeparationRules {
+    rules: SeparationRule[];
+}
+export interface SeparationRule {
+    concern: string;
+    belongsIn: string;
+    ruleText: string;
+    example: string;
+    indicators?: string[];
+    antiIndicators?: string[];
+}
+export interface PatternRules {
+    naming?: Record<string, string>;
+    dataFlow?: {
+        direction: string;
+        rules: string[];
+    };
+    errorHandling?: {
+        recommended: string;
+    };
+    custom?: Record<string, unknown>;
+}
+export interface AntiPattern {
+    id: string;
+    severity: IssueSeverity;
+    description: string;
+    badExample: string;
+    goodExample: string;
+}
+export interface SkillWarning {
+    file: string;
+    message: string;
+}
+export interface SkillLoadResult {
+    skills: ArchitectureSkill[];
+    warnings: SkillWarning[];
+}
+export interface ProjectCharacteristics {
+    rootDir: string;
+    dependencies: Set<string>;
+    files: string[];
+    sourceText: string;
+}
+export interface SkillMatch {
+    skill: ArchitectureSkill;
+    confidence: SkillConfidence;
+    score: number;
+    reasons: string[];
+    primary: boolean;
+}
+export interface StructureComparison {
+    skillId: string;
+    entries: StructureComparisonEntry[];
+    isAvailable: boolean;
+}
+export interface StructureComparisonEntry {
+    path: string;
+    purpose: string;
+    required: boolean;
+    status: 'present' | 'missing';
+}

package/dist/types/skill.js

@@ -0,0 +1,2 @@
+export const SUPPORTED_SKILL_SCHEMA_VERSION = '2.0.0';
+//# sourceMappingURL=skill.js.map

package/dist/types/skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../src/types/skill.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,8BAA8B,GAAG,OAAO,CAAC"}

package/dist/utils/agent-detector.d.ts

@@ -0,0 +1,2 @@
+export type AgentType = 'claude' | 'cursor' | 'windsurf' | 'copilot' | 'generic';
+export declare function detectAgent(dir: string): AgentType;

package/dist/utils/agent-detector.js

@@ -0,0 +1,22 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+const AGENT_DIRS = [
+    { dir: '.claude', agent: 'claude' },
+    { dir: '.cursor', agent: 'cursor' },
+    { dir: '.windsurf', agent: 'windsurf' },
+    { dir: '.github', agent: 'copilot' }
+];
+export function detectAgent(dir) {
+    try {
+        for (const { dir: agentDir, agent } of AGENT_DIRS) {
+            if (existsSync(path.join(dir, agentDir))) {
+                return agent;
+            }
+        }
+    }
+    catch {
+        // fs errors return generic
+    }
+    return 'generic';
+}
+//# sourceMappingURL=agent-detector.js.map

package/dist/utils/agent-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-detector.js","sourceRoot":"","sources":["../../src/utils/agent-detector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,IAAI,MAAM,WAAW,CAAC;AAI7B,MAAM,UAAU,GAA6C;IAC3D,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE;IACnC,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE;IACnC,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE;IACvC,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;CACrC,CAAC;AAEF,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,IAAI,CAAC;QACH,KAAK,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,UAAU,EAAE,CAAC;YAClD,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;gBACzC,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/utils/interactive.d.ts

@@ -0,0 +1,6 @@
+export interface InteractiveStreams {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}
+export declare function isInteractiveTerminal(streams?: InteractiveStreams): boolean;
+export declare function promptForDirectory(message?: string): Promise<string>;

package/dist/utils/interactive.js

@@ -0,0 +1,15 @@
+import { input } from '@inquirer/prompts';
+export function isInteractiveTerminal(streams = {}) {
+    const stdin = streams.stdin ?? process.stdin;
+    const stdout = streams.stdout ?? process.stdout;
+    return stdin.isTTY === true && stdout.isTTY === true;
+}
+export async function promptForDirectory(message = 'Directory to scan:') {
+    const answer = await input({
+        message,
+        default: '.',
+        required: true
+    });
+    return answer.trim();
+}
+//# sourceMappingURL=interactive.js.map