docorbit 0.1.0 → 0.1.2

package/dist/apps/cli/src/formatters/knowledge.js

@@ -0,0 +1,229 @@
+import { RESET, BOLD, DIM, GREEN, BLUE, CYAN, YELLOW, RED, MAGENTA } from "./colors.js";
+export function formatApiEndpoints(endpoints, query) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${CYAN}DocOrbit${RESET} ${DIM}— API Intelligence for: "${query || '*'}"${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    if (endpoints.length === 0) {
+        lines.push(`  ${YELLOW}No matching API endpoints found.${RESET}`);
+        lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    for (let i = 0; i < endpoints.length; i++) {
+        const ep = endpoints[i];
+        let methodColor = GREEN;
+        if (ep.method === 'post')
+            methodColor = BLUE;
+        else if (ep.method === 'put')
+            methodColor = YELLOW;
+        else if (ep.method === 'delete')
+            methodColor = RED;
+        else if (ep.method === 'patch')
+            methodColor = MAGENTA;
+        const methodBadge = `${methodColor}${BOLD}[${ep.method.toUpperCase()}]${RESET}`;
+        const depBadge = ep.deprecated ? ` ${RED}${BOLD}[DEPRECATED]${RESET}` : '';
+        const verBadge = ep.docVersion ? ` ${DIM}(${ep.docVersion})${RESET}` : '';
+        lines.push(`  ${BOLD}${i + 1}.${RESET} ${methodBadge} ${BOLD}${CYAN}${ep.path}${RESET}${depBadge}${verBadge}`);
+        if (ep.summary) {
+            lines.push(`     ${BOLD}${ep.summary}${RESET}`);
+        }
+        if (ep.description && ep.description !== ep.summary) {
+            lines.push(`     ${DIM}${ep.description.slice(0, 120)}${ep.description.length > 120 ? '...' : ''}${RESET}`);
+        }
+        if (ep.parameters.length > 0) {
+            const paramStr = ep.parameters.map(p => {
+                const req = p.required ? `${RED}*${RESET}` : '';
+                return `${p.name}${req} (${p.in}:${p.type || 'any'})`;
+            }).join(', ');
+            lines.push(`     ${DIM}Params: ${paramStr}${RESET}`);
+        }
+        if (ep.auth.length > 0) {
+            const authStr = ep.auth.map(a => `${a.type}${a.scheme ? `:${a.scheme}` : ''}`).join(', ');
+            lines.push(`     ${DIM}Auth: ${authStr}${RESET}`);
+        }
+        if (ep.pagination) {
+            lines.push(`     ${DIM}Pagination: ${ep.pagination.type} (${ep.pagination.parameters.join(', ')})${RESET}`);
+        }
+        if (ep.errors.length > 0) {
+            const errorCodes = ep.errors.map(e => e.statusCode).join(', ');
+            lines.push(`     ${DIM}Error Codes: ${errorCodes}${RESET}`);
+        }
+        if (ep.provenance?.sourceUrl) {
+            lines.push(`     ${DIM}Source: ${ep.provenance.sourceUrl}${RESET}`);
+        }
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatIndexedExamples(examples, task) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${CYAN}DocOrbit${RESET} ${DIM}— Code Example Intelligence for: "${task || '*'}"${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    if (examples.length === 0) {
+        lines.push(`  ${YELLOW}No matching code examples found.${RESET}`);
+        lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    for (let i = 0; i < examples.length; i++) {
+        const ex = examples[i];
+        const fwBadge = ex.framework ? ` ${MAGENTA}[${ex.framework}]${RESET}` : '';
+        const langBadge = `${GREEN}[${ex.language}]${RESET}`;
+        const verBadge = ex.docVersion ? ` ${DIM}(${ex.docVersion})${RESET}` : '';
+        const authBadge = ex.sourceAuthority === 'official' ? `${BLUE}[official]${RESET}` : `${DIM}[community]${RESET}`;
+        lines.push(`  ${BOLD}${i + 1}.${RESET} ${CYAN}${ex.task}${RESET} ${langBadge}${fwBadge} ${authBadge}${verBadge}`);
+        if (ex.relatedApi) {
+            lines.push(`     ${BOLD}Target API:${RESET} ${BLUE}${ex.relatedApi}${RESET}`);
+        }
+        if (ex.relatedSymbol) {
+            lines.push(`     ${BOLD}Symbol:${RESET} ${MAGENTA}${ex.relatedSymbol}${RESET}`);
+        }
+        lines.push(`     ${DIM}┌── code snippet ──────────────────────────${RESET}`);
+        const codeLines = ex.code.split('\n').slice(0, 15);
+        for (const cl of codeLines) {
+            lines.push(`     ${DIM}│${RESET} ${cl}`);
+        }
+        if (ex.code.split('\n').length > 15) {
+            lines.push(`     ${DIM}│ ... (${ex.code.split('\n').length - 15} more lines)${RESET}`);
+        }
+        lines.push(`     ${DIM}└──────────────────────────────────────────${RESET}`);
+        lines.push(`     ${DIM}Source: ${ex.sourceUrl}${RESET}`);
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatPitfalls(pitfalls, task) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${YELLOW}DocOrbit${RESET} ${DIM}— Pitfalls & Warnings for: "${task || '*'}"${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    if (pitfalls.length === 0) {
+        lines.push(`  ${GREEN}No matching pitfalls or warnings found.${RESET}`);
+        lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    for (let i = 0; i < pitfalls.length; i++) {
+        const pf = pitfalls[i];
+        let badgeColor = YELLOW;
+        if (pf.kind === 'breaking_change' || pf.kind === 'removed' || pf.kind === 'security') {
+            badgeColor = RED;
+        }
+        else if (pf.kind === 'deprecated') {
+            badgeColor = MAGENTA;
+        }
+        const kindBadge = `${badgeColor}${BOLD}[${pf.kind.toUpperCase().replace(/_/g, ' ')}]${RESET}`;
+        const verBadge = pf.docVersion ? ` ${DIM}(${pf.docVersion})${RESET}` : '';
+        lines.push(`  ${BOLD}${i + 1}.${RESET} ${kindBadge} ${BOLD}${pf.title}${RESET}${verBadge}`);
+        if (pf.relatedApi) {
+            lines.push(`     ${DIM}Related API: ${BLUE}${pf.relatedApi}${RESET}`);
+        }
+        lines.push(`     ${DIM}│${RESET} ${pf.content}`);
+        if (pf.provenance?.sourceUrl) {
+            lines.push(`     ${DIM}Source: ${pf.provenance.sourceUrl}${RESET}`);
+        }
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatRecipe(recipe) {
+    const lines = [];
+    const confidencePct = Math.round(recipe.confidence * 100);
+    const confColor = confidencePct >= 70 ? GREEN : (confidencePct >= 40 ? YELLOW : RED);
+    lines.push('');
+    lines.push(`${BOLD}${GREEN}DocOrbit${RESET} ${DIM}— Implementation Recipe${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push(`${BOLD}Goal:${RESET}       ${CYAN}${recipe.goal}${RESET}`);
+    lines.push(`${BOLD}Confidence:${RESET} ${confColor}${confidencePct}%${RESET}`);
+    if (recipe.docVersion) {
+        lines.push(`${BOLD}Version:${RESET}    ${MAGENTA}${recipe.docVersion}${RESET}`);
+    }
+    lines.push('');
+    // Prerequisites
+    lines.push(`${BOLD}Prerequisites (${recipe.prerequisites.length}):${RESET}`);
+    lines.push(`${DIM}${'─'.repeat(64)}${RESET}`);
+    if (recipe.prerequisites.length === 0) {
+        lines.push(`  ${DIM}No special prerequisites documented.${RESET}`);
+    }
+    else {
+        for (const pre of recipe.prerequisites) {
+            const badge = pre.evidenceLevel === 'documented_fact'
+                ? `${GREEN}[FACT]${RESET}`
+                : `${YELLOW}[INFERRED]${RESET}`;
+            lines.push(`  • ${badge} ${pre.text}`);
+        }
+    }
+    lines.push('');
+    // Ordered Implementation Steps
+    lines.push(`${BOLD}Implementation Steps (${recipe.orderedSteps.length}):${RESET}`);
+    lines.push(`${DIM}${'─'.repeat(64)}${RESET}`);
+    for (const s of recipe.orderedSteps) {
+        let badge = `${GREEN}[FACT]${RESET}`;
+        if (s.evidenceLevel === 'inferred_relationship')
+            badge = `${YELLOW}[INFERRED]${RESET}`;
+        else if (s.evidenceLevel === 'missing_information')
+            badge = `${RED}[MISSING]${RESET}`;
+        lines.push(`  ${BOLD}${s.step}.${RESET} ${badge} ${BOLD}${CYAN}${s.title}${RESET}`);
+        if (s.apiEndpoint) {
+            lines.push(`     ${BOLD}API Endpoint:${RESET} ${BLUE}${s.apiEndpoint}${RESET}`);
+        }
+        lines.push(`     ${s.description}`);
+        if (s.exampleCode) {
+            lines.push(`     ${DIM}┌── example ────────────────────────────────${RESET}`);
+            const codeLines = s.exampleCode.split('\n').slice(0, 10);
+            for (const cl of codeLines) {
+                lines.push(`     ${DIM}│${RESET} ${cl}`);
+            }
+            if (s.exampleCode.split('\n').length > 10) {
+                lines.push(`     ${DIM}│ ... (${s.exampleCode.split('\n').length - 10} more lines)${RESET}`);
+            }
+            lines.push(`     ${DIM}└──────────────────────────────────────────${RESET}`);
+        }
+        if (s.pitfalls && s.pitfalls.length > 0) {
+            for (const pf of s.pitfalls) {
+                lines.push(`     ${YELLOW}⚠ ${pf}${RESET}`);
+            }
+        }
+        if (s.sourceUrl) {
+            lines.push(`     ${DIM}Source: ${s.sourceUrl}${RESET}`);
+        }
+        lines.push('');
+    }
+    // Evidence-Based Validation Steps
+    lines.push(`${BOLD}Validation Steps (${recipe.validationSteps.length}):${RESET}`);
+    lines.push(`${DIM}${'─'.repeat(64)}${RESET}`);
+    for (const vs of recipe.validationSteps) {
+        let badge = `${GREEN}[FACT]${RESET}`;
+        if (vs.evidenceLevel === 'inferred_relationship')
+            badge = `${YELLOW}[INFERRED]${RESET}`;
+        else if (vs.evidenceLevel === 'missing_information')
+            badge = `${RED}[MISSING]${RESET}`;
+        lines.push(`  ${BOLD}${vs.step}.${RESET} ${badge} ${vs.description}`);
+        if (vs.expectedResponse) {
+            lines.push(`     ${DIM}Expected Response:${RESET} ${vs.expectedResponse.slice(0, 100)}`);
+        }
+        if (vs.testPattern) {
+            lines.push(`     ${DIM}Test Pattern:${RESET} ${vs.testPattern.slice(0, 100)}`);
+        }
+    }
+    lines.push('');
+    // Sources consulted
+    if (recipe.sources.length > 0) {
+        lines.push(`${BOLD}Sources Consulted:${RESET}`);
+        for (const src of recipe.sources) {
+            lines.push(`  ${DIM}• ${src}${RESET}`);
+        }
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/apps/cli/src/formatters/retrieval.d.ts

@@ -0,0 +1,3 @@
+import type { SearchResult, ContextPackage } from '../../../../packages/shared/src/index.ts';
+export declare function formatSearchResults(query: string, results: SearchResult[]): string;
+export declare function formatContextPackage(pkg: ContextPackage): string;

package/dist/apps/cli/src/formatters/retrieval.js

@@ -0,0 +1,61 @@
+import { RESET, BOLD, DIM, GREEN, CYAN, YELLOW, MAGENTA } from "./colors.js";
+export function formatSearchResults(query, results) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${CYAN}DocOrbit${RESET} ${DIM}— Search Results for: "${query}"${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    if (results.length === 0) {
+        lines.push(`  ${YELLOW}No matching documentation chunks found.${RESET}`);
+        lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    for (let i = 0; i < results.length; i++) {
+        const res = results[i];
+        const chunk = res.chunk;
+        const breadcrumb = chunk.sectionPath.length > 0 ? chunk.sectionPath.join(' > ') : (chunk.title || 'General');
+        lines.push(`  ${BOLD}${i + 1}.${RESET} ${CYAN}${breadcrumb}${RESET} ${GREEN}(Score: ${res.score})${RESET}`);
+        lines.push(`     ${DIM}Type: ${chunk.chunkType} | Est. Tokens: ~${chunk.tokenEstimate} | Chunk: ${chunk.id}${RESET}`);
+        if (res.matchReasons.length > 0) {
+            lines.push(`     ${DIM}Matches: ${res.matchReasons.join(' • ')}${RESET}`);
+        }
+        if (res.symbols.length > 0) {
+            lines.push(`     ${MAGENTA}Symbols: ${res.symbols.map(s => s.name).join(', ')}${RESET}`);
+        }
+        const preview = chunk.content.split('\n').filter(l => l.trim().length > 0).slice(0, 3).join('\n     ');
+        lines.push(`     ${DIM}│${RESET} ${preview}`);
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatContextPackage(pkg) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${GREEN}DocOrbit${RESET} ${DIM}— Assembled Context Package${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push(`${BOLD}Task:${RESET}             ${CYAN}${pkg.task}${RESET}`);
+    lines.push(`${BOLD}Detected Intent:${RESET}  ${MAGENTA}${pkg.detectedIntent}${RESET}`);
+    lines.push(`${BOLD}Estimated Tokens:${RESET} ~${pkg.totalEstimatedTokens} / ${pkg.tokenBudget} (heuristic)`);
+    lines.push(`${BOLD}Chunks Included:${RESET}  ${pkg.chunks.length}`);
+    lines.push(`${BOLD}Sources Cited:${RESET}    ${pkg.sources.length > 0 ? pkg.sources.join(', ') : 'Local documentation'}`);
+    if (pkg.warnings.length > 0) {
+        lines.push('');
+        lines.push(`${YELLOW}${BOLD}Advisories & Warnings (${pkg.warnings.length}):${RESET}`);
+        for (const w of pkg.warnings) {
+            lines.push(`  ${YELLOW}⚠ ${w}${RESET}`);
+        }
+    }
+    lines.push('');
+    lines.push(`${BOLD}Package Markdown Preview:${RESET}`);
+    lines.push(`${DIM}${'─'.repeat(64)}${RESET}`);
+    const previewLines = pkg.markdown.split('\n').slice(0, 20);
+    lines.push(previewLines.join('\n'));
+    if (pkg.markdown.split('\n').length > 20) {
+        lines.push(`\n${DIM}... (${pkg.markdown.split('\n').length - 20} more lines in full package)${RESET}`);
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/{apps/cli/src/formatters/terminal.ts → dist/apps/cli/src/formatters/terminal.d.ts}

@@ -3,4 +3,3 @@ export * from './inspection.ts';
 export * from './retrieval.ts';
 export * from './knowledge.ts';
 export * from './verification.ts';
-

package/dist/apps/cli/src/formatters/terminal.js

@@ -0,0 +1,5 @@
+export * from "./colors.js";
+export * from "./inspection.js";
+export * from "./retrieval.js";
+export * from "./knowledge.js";
+export * from "./verification.js";

package/dist/apps/cli/src/formatters/verification.d.ts

@@ -0,0 +1,4 @@
+import type { DocDiffResult, ImpactAnalysisResult, VerificationResult } from '../../../../packages/shared/src/index.ts';
+export declare function formatVerificationReport(result: VerificationResult): string;
+export declare function formatDiffReport(diff: DocDiffResult): string;
+export declare function formatImpactReport(impact: ImpactAnalysisResult): string;

package/dist/apps/cli/src/formatters/verification.js

@@ -0,0 +1,102 @@
+import { RESET, BOLD, DIM, GREEN, CYAN, YELLOW, RED } from "./colors.js";
+export function formatVerificationReport(result) {
+    const lines = [];
+    const verdictColor = result.verdict === 'verified'
+        ? GREEN
+        : result.verdict === 'warning'
+            ? YELLOW
+            : result.verdict === 'mismatch'
+                ? RED
+                : CYAN;
+    lines.push(`${BOLD}${CYAN}DocOrbit — Code & Schema Verification${RESET}`);
+    lines.push(`Verdict: ${verdictColor}${BOLD}${result.verdict.toUpperCase()}${RESET}`);
+    lines.push(`Summary: ${result.summary}`);
+    if (result.targetVersion) {
+        lines.push(`Target Version:  ${YELLOW}${result.targetVersion}${RESET}`);
+    }
+    if (result.projectVersion) {
+        lines.push(`Project Version: ${YELLOW}${result.projectVersion}${RESET}`);
+    }
+    lines.push(`Total Checks:    ${result.totalChecks}\n`);
+    if (result.findings.length === 0) {
+        lines.push(`${GREEN}✔ No schema mismatches, deprecations, or syntax issues detected.${RESET}`);
+        return lines.join('\n');
+    }
+    lines.push(`${BOLD}Findings (${result.findings.length}):${RESET}`);
+    for (const f of result.findings) {
+        const fColor = f.severity === 'error' ? RED : f.severity === 'warning' ? YELLOW : CYAN;
+        const loc = f.location?.line ? ` (Line ${f.location.line})` : '';
+        lines.push(`  ${fColor}• [${f.rule.toUpperCase()}]${loc}: ${f.message}${RESET}`);
+        if (f.location?.snippet) {
+            lines.push(`    ${DIM}${f.location.snippet}${RESET}`);
+        }
+        if (f.expected) {
+            lines.push(`    ${DIM}Expected: ${String(f.expected)}${RESET}`);
+        }
+        if (f.actual) {
+            lines.push(`    ${DIM}Actual:   ${String(f.actual)}${RESET}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatDiffReport(diff) {
+    const lines = [];
+    const from = diff.fromVersion || diff.fromSnapshotId || 'previous';
+    const to = diff.toVersion || diff.toSnapshotId || 'latest';
+    lines.push(`${BOLD}${CYAN}DocOrbit — Documentation & API Diff${RESET}`);
+    lines.push(`Comparing: ${YELLOW}${from}${RESET} ➔ ${YELLOW}${to}${RESET}`);
+    lines.push(`Endpoints: +${diff.summary.endpointsAdded} added, -${diff.summary.endpointsRemoved} removed, ~${diff.summary.endpointsModified} modified, !${diff.summary.endpointsDeprecated} deprecated`);
+    lines.push(`Pitfalls:  +${diff.summary.pitfallsAdded} added, -${diff.summary.pitfallsRemoved} removed\n`);
+    if (diff.apiChanges.length > 0) {
+        lines.push(`${BOLD}API Endpoint Changes:${RESET}`);
+        for (const ep of diff.apiChanges) {
+            const badge = ep.changeType === 'added'
+                ? `${GREEN}[ADDED]${RESET}`
+                : ep.changeType === 'removed'
+                    ? `${RED}[REMOVED]${RESET}`
+                    : ep.changeType === 'deprecated'
+                        ? `${YELLOW}[DEPRECATED]${RESET}`
+                        : `${CYAN}[MODIFIED]${RESET}`;
+            lines.push(`  ${badge} ${ep.method.toUpperCase()} ${ep.path}`);
+            if (ep.changes) {
+                for (const ch of ep.changes) {
+                    lines.push(`    ${DIM}• ${ch}${RESET}`);
+                }
+            }
+        }
+        lines.push('');
+    }
+    if (diff.pitfallChanges.length > 0) {
+        lines.push(`${BOLD}Pitfall Changes:${RESET}`);
+        for (const p of diff.pitfallChanges) {
+            const badge = p.changeType === 'added' ? `${YELLOW}[NEW WARNING]${RESET}` : `${DIM}[REMOVED]${RESET}`;
+            lines.push(`  ${badge} ${p.pitfall.kind}: ${p.pitfall.title}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatImpactReport(impact) {
+    const lines = [];
+    lines.push(`${BOLD}${CYAN}DocOrbit — Project Impact Analysis${RESET}`);
+    lines.push(`Workspace:      ${impact.projectDir}`);
+    lines.push(`Files Scanned:  ${impact.totalFilesScanned}`);
+    lines.push(`Impacted Files: ${impact.affectedFilesCount}`);
+    lines.push(`Total Matches:  ${impact.affectedLocations.length}\n`);
+    if (impact.affectedLocations.length === 0) {
+        lines.push(`${GREEN}✔ Zero project files impacted by documentation/API changes.${RESET}`);
+        return lines.join('\n');
+    }
+    lines.push(`${BOLD}Impacted Locations:${RESET}`);
+    for (const loc of impact.affectedLocations) {
+        const cert = loc.certainty === 'high'
+            ? `${RED}[HIGH]${RESET}`
+            : loc.certainty === 'medium'
+                ? `${YELLOW}[MED]${RESET}`
+                : `${DIM}[HEUR]${RESET}`;
+        lines.push(`  ${cert} ${BOLD}${loc.filePath}:${loc.line}${RESET}`);
+        lines.push(`    ${YELLOW}Reason:  ${loc.reason}${RESET}`);
+        lines.push(`    ${DIM}Pattern: ${loc.matchedPattern}${RESET}`);
+        lines.push(`    ${DIM}Snippet: ${loc.snippet}${RESET}\n`);
+    }
+    return lines.join('\n');
+}

package/dist/apps/cli/src/index.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): Promise<void>;