@popoverai/dotrequirements 0.23.0 → 0.24.0

package/dist/commands/report.js

@@ -1,152 +1,207 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { findProjectRoot } from '../utils/project-settings.js';
-import { findRequirementsDir, readTrackingEntries, isCacheStale, } from '../harness/cache.js';
-function buildCoverageEntries(lookup, entries, filterKey) {
-    // Aggregate tracking by key
-    const locationsByKey = new Map();
-    for (const entry of entries) {
-        if (!locationsByKey.has(entry.requirementKey)) {
-            locationsByKey.set(entry.requirementKey, new Set());
-        }
-        locationsByKey.get(entry.requirementKey).add(entry.callerLocation);
-    }
-    const results = [];
-    for (const [key, req] of Object.entries(lookup.requirements)) {
-        // Skip alias entries to avoid double-counting
-        if (req.isAlias)
-            continue;
-        // Filter if requested
-        if (filterKey && key !== filterKey && !key.startsWith(filterKey + '.')) {
-            continue;
-        }
-        // Collect locations from both the numeric key and any alias keys that map to the same id
-        const locations = new Set();
-        const keyLocations = locationsByKey.get(key);
-        if (keyLocations)
-            keyLocations.forEach(l => locations.add(l));
-        // Also check if tracking data was written using a label path
-        for (const [aliasKey, aliasReq] of Object.entries(lookup.requirements)) {
-            if (aliasReq.isAlias && aliasReq.id === req.id) {
-                const aliasLocations = locationsByKey.get(aliasKey);
-                if (aliasLocations)
-                    aliasLocations.forEach(l => locations.add(l));
-            }
+import { getProjectCoverage, getRequirementCoverage, } from "../requirements/cloud-coverage.js";
+import { buildLocalReport, } from "../requirements/coverage.js";
+import { findProjectRoot, getProjectCredentials, } from "../utils/project-settings.js";
+const CONVEX_URL = "https://data.dotrequirements.io";
+export async function reportCommand(options) {
+    const source = options.source ?? "local";
+    const format = options.format ?? "console";
+    if (source === "local" && (options.branch || options.since !== undefined)) {
+        throw new Error("--branch and --since require --source cloud. Local reports cover only the most recent test run on this machine.");
+    }
+    if (source === "local") {
+        const projectRoot = findProjectRoot(process.cwd());
+        if (!projectRoot) {
+            throw new Error('Could not find .requirements/ directory. Run "dotrequirements init" to initialize your project.');
         }
-        results.push({
-            key,
-            label: req.label || null,
-            content: req.content,
-            tested: locations.size > 0,
-            locations: Array.from(locations),
+        const report = buildLocalReport({
+            projectRoot,
+            requirementFilter: options.requirement,
         });
+        for (const warning of report.warnings) {
+            console.error(`Warning: ${warning}\n`);
+        }
+        console.log(printLocalReport(report, format));
+        return;
+    }
+    // source === "cloud"
+    let projectId;
+    let projectSecret;
+    try {
+        const creds = getProjectCredentials(process.cwd());
+        projectId = creds.projectId;
+        projectSecret = creds.projectSecret;
+    }
+    catch (error) {
+        throw new Error(`Cloud report requires cloud credentials. Run \`dotrequirements link\` to connect this project to the cloud.\n` +
+            `(${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (options.requirement) {
+        const record = await getRequirementCoverage(options.requirement, projectId, projectSecret, CONVEX_URL);
+        console.log(printCloudRequirement(record, format));
+        return;
+    }
+    const record = await getProjectCoverage(projectId, projectSecret, CONVEX_URL, {
+        branch: options.branch,
+        sinceTimestamp: options.since,
+    });
+    console.log(printCloudProject(record, format, {
+        branch: options.branch,
+        since: options.since,
+    }));
+}
+function printLocalReport(report, format) {
+    switch (format) {
+        case "json":
+            return JSON.stringify({
+                source: "local",
+                summary: report.summary,
+                requirements: report.entries,
+            }, null, 2);
+        case "markdown":
+            return formatLocalMarkdown(report);
+        default:
+            return formatLocalConsole(report);
     }
-    return results;
 }
-function formatConsole(coverage) {
-    const tested = coverage.filter(c => c.tested).length;
-    const total = coverage.length;
-    const pct = total > 0 ? ((tested / total) * 100).toFixed(1) : '0.0';
-    let out = `\n=== Requirements Coverage Report ===\n`;
-    out += `\nTotal: ${total} | Tested: ${tested} | Untested: ${total - tested} | Coverage: ${pct}%\n`;
-    const testedEntries = coverage.filter(c => c.tested);
+function formatLocalConsole(report) {
+    const { total, tested, untested, coveragePercent } = report.summary;
+    let out = `\n=== Requirements Coverage Report (local) ===\n`;
+    out += `\nTotal: ${total} | Tested: ${tested} | Untested: ${untested} | Coverage: ${coveragePercent}%\n`;
+    const testedEntries = report.entries.filter((c) => c.tested);
     if (testedEntries.length > 0) {
-        out += '\n✓ Tested:\n';
+        out += "\n✓ Tested:\n";
         for (const c of testedEntries) {
-            const preview = c.content.length > 60 ? c.content.substring(0, 60) + '...' : c.content;
-            out += `  ${c.key}: ${preview}\n`;
+            out += `  ${c.key}: ${preview(c.content, 60)}\n`;
             for (const loc of c.locations) {
                 out += `    ← ${loc}\n`;
             }
         }
     }
-    const untestedEntries = coverage.filter(c => !c.tested);
+    const untestedEntries = report.entries.filter((c) => !c.tested);
     if (untestedEntries.length > 0) {
-        out += '\n✗ Untested:\n';
+        out += "\n✗ Untested:\n";
         for (const c of untestedEntries) {
-            const preview = c.content.length > 60 ? c.content.substring(0, 60) + '...' : c.content;
-            out += `  ${c.key}: ${preview}\n`;
+            out += `  ${c.key}: ${preview(c.content, 60)}\n`;
         }
     }
-    out += '\n====================================\n';
+    out += "\n=============================================\n";
     return out;
 }
-function formatJson(coverage) {
-    const tested = coverage.filter(c => c.tested).length;
-    const total = coverage.length;
-    return JSON.stringify({
-        summary: {
-            total,
-            tested,
-            untested: total - tested,
-            coveragePercent: total > 0 ? parseFloat(((tested / total) * 100).toFixed(1)) : 0,
-        },
-        requirements: coverage,
-    }, null, 2);
-}
-function formatMarkdown(coverage) {
-    const tested = coverage.filter(c => c.tested).length;
-    const total = coverage.length;
-    const pct = total > 0 ? ((tested / total) * 100).toFixed(1) : '0.0';
-    let out = `# Requirements Coverage Report\n\n`;
-    out += `**Coverage:** ${tested}/${total} (${pct}%)\n\n`;
+function formatLocalMarkdown(report) {
+    const { total, tested, coveragePercent } = report.summary;
+    let out = `# Requirements Coverage Report (local)\n\n`;
+    out += `**Coverage:** ${tested}/${total} (${coveragePercent}%)\n\n`;
     out += `| Requirement | Status | Locations |\n`;
     out += `|---|---|---|\n`;
-    for (const c of coverage) {
-        const status = c.tested ? '✓' : '✗';
-        const locs = c.locations.join(', ') || '-';
-        const preview = c.content.length > 40 ? c.content.substring(0, 40) + '...' : c.content;
-        out += `| ${c.key}: ${preview} | ${status} | ${locs} |\n`;
+    for (const c of report.entries) {
+        const status = c.tested ? "✓" : "✗";
+        const locs = c.locations.join(", ") || "-";
+        out += `| ${c.key}: ${preview(c.content, 40)} | ${status} | ${locs} |\n`;
     }
     return out;
 }
-export async function reportCommand(options) {
-    const projectRoot = findProjectRoot(process.cwd());
-    if (!projectRoot) {
-        throw new Error('Could not find .requirements directory. Run "dotrequirements init" to initialize your project.');
-    }
-    const requirementsDir = findRequirementsDir(projectRoot);
-    const cacheDir = path.join(requirementsDir, '.cache');
-    const lookupPath = path.join(cacheDir, 'lookup.json');
-    if (!fs.existsSync(lookupPath)) {
-        throw new Error('No lookup cache found. Run "dotrequirements prepare" first to build the cache.');
-    }
-    // Read lookup cache
-    const lookupContent = fs.readFileSync(lookupPath, 'utf-8');
-    const lookup = JSON.parse(lookupContent);
-    // Warn if cache is stale (requirements changed since last prepare)
-    try {
-        const cacheStat = fs.statSync(lookupPath);
-        if (isCacheStale(requirementsDir, cacheStat.mtimeMs)) {
-            console.error('Warning: Cache may be stale — requirements have changed since last prepare. Run "dotrequirements prepare" to rebuild.\n');
+function printCloudRequirement(record, format) {
+    if (format === "json") {
+        return JSON.stringify({ source: "cloud", requirement: record }, null, 2);
+    }
+    if (!record.lastTestedAt) {
+        return `\n${record.requirementKey}: never tested on the cloud-persisted record.\n`;
+    }
+    const lastTested = new Date(record.lastTestedAt).toISOString();
+    const lines = [];
+    lines.push(`\n=== Coverage for ${record.requirementKey} (cloud) ===\n`);
+    lines.push(`Last tested: ${lastTested}`);
+    if (record.branch)
+        lines.push(`Branch: ${record.branch}`);
+    if (record.testFile) {
+        lines.push(`Test: ${record.testFile}${record.testLine ? `:${record.testLine}` : ""}`);
+    }
+    if (record.allBranches.length > 1) {
+        lines.push(`\nAlso tested on:`);
+        for (const b of record.allBranches) {
+            if (b.branch === record.branch)
+                continue;
+            lines.push(`  ${b.branch} — ${new Date(b.lastTestedAt).toISOString()}${b.testFile ? ` (${b.testFile}${b.testLine ? `:${b.testLine}` : ""})` : ""}`);
         }
     }
-    catch {
-        // Ignore stat errors
+    lines.push("");
+    if (format === "markdown") {
+        return [
+            `# Coverage for ${record.requirementKey} (cloud)\n`,
+            `**Last tested:** ${lastTested}`,
+            record.branch ? `**Branch:** ${record.branch}` : "",
+            record.testFile
+                ? `**Test location:** \`${record.testFile}${record.testLine ? `:${record.testLine}` : ""}\``
+                : "",
+        ]
+            .filter(Boolean)
+            .join("\n");
     }
-    // Read tracking entries
-    const trackingPath = path.join(cacheDir, 'tracking.jsonl');
-    const trackingExists = fs.existsSync(trackingPath);
-    const entries = readTrackingEntries(requirementsDir);
-    if (!trackingExists) {
-        console.error('Warning: No tracking data found. Run your tests first, or run "dotrequirements prepare" to start a new tracking session.\n');
+    return lines.join("\n");
+}
+function printCloudProject(record, format, filters) {
+    if (format === "json") {
+        return JSON.stringify({ source: "cloud", filters, summary: cloudSummary(record), ...record }, null, 2);
     }
-    else if (entries.length === 0) {
-        console.error('Warning: Tracking file is empty — no requirements were tracked during tests.\n');
+    const summary = cloudSummary(record);
+    const filterNote = formatCloudFilters(filters);
+    if (format === "markdown") {
+        let out = `# Requirements Coverage Report (cloud)\n\n`;
+        if (filterNote)
+            out += `${filterNote}\n\n`;
+        out += `**Coverage:** ${summary.tested}/${summary.total} (${summary.coveragePercent}%)\n\n`;
+        if (record.tested.length > 0) {
+            out += `## Tested\n\n`;
+            for (const t of record.tested) {
+                out += `- **${t.requirementKey}** [${t.branch}] — ${new Date(t.lastTestedAt).toISOString()}\n`;
+            }
+            out += "\n";
+        }
+        if (record.untested.length > 0) {
+            out += `## Untested\n\n`;
+            for (const key of record.untested) {
+                out += `- ${key}\n`;
+            }
+        }
+        return out;
     }
-    const coverage = buildCoverageEntries(lookup, entries, options.requirement);
-    const format = options.format || 'console';
-    switch (format) {
-        case 'json':
-            console.log(formatJson(coverage));
-            break;
-        case 'markdown':
-            console.log(formatMarkdown(coverage));
-            break;
-        case 'console':
-        default:
-            console.log(formatConsole(coverage));
-            break;
+    let out = `\n=== Project Coverage Report (cloud) ===\n`;
+    if (filterNote)
+        out += `${filterNote}\n`;
+    out += `\nTotal: ${summary.total} | Tested: ${summary.tested} | Untested: ${summary.untested} | Coverage: ${summary.coveragePercent}%\n`;
+    if (record.tested.length > 0) {
+        out += "\n✓ Tested:\n";
+        for (const t of record.tested) {
+            const date = new Date(t.lastTestedAt).toISOString();
+            out += `  ${t.requirementKey} [${t.branch}] — ${date}\n`;
+        }
+    }
+    if (record.untested.length > 0) {
+        out += "\n✗ Untested:\n";
+        for (const key of record.untested) {
+            out += `  ${key}\n`;
+        }
+    }
+    out += "\n=======================================\n";
+    return out;
+}
+function cloudSummary(record) {
+    const tested = record.tested.length;
+    const untested = record.untested.length;
+    const total = tested + untested;
+    const coveragePercent = total > 0 ? parseFloat(((tested / total) * 100).toFixed(1)) : 0;
+    return { total, tested, untested, coveragePercent };
+}
+function formatCloudFilters(filters) {
+    const parts = [];
+    if (filters.branch)
+        parts.push(`branch=${filters.branch}`);
+    if (filters.since !== undefined) {
+        parts.push(`since=${new Date(filters.since).toISOString()}`);
     }
+    return parts.length > 0 ? `Filters: ${parts.join(", ")}` : "";
+}
+function preview(s, max) {
+    return s.length > max ? `${s.substring(0, max)}...` : s;
 }
 //# sourceMappingURL=report.js.map

package/dist/commands/requirements-for.d.ts

@@ -0,0 +1,2 @@
+export declare function requirementsForCommand(testFile: string): Promise<void>;
+//# sourceMappingURL=requirements-for.d.ts.map

package/dist/commands/requirements-for.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { findRequirementsInFile } from "../requirements/grep.js";
+import { getRequirementById, loadAllRequirements, } from "../requirements/index.js";
+export async function requirementsForCommand(testFile) {
+    const workspaceRoot = process.cwd();
+    const fullPath = resolve(workspaceRoot, testFile);
+    // CLI-FIND-MAP-1.1: missing file → error + non-zero exit
+    if (!existsSync(fullPath)) {
+        throw new Error(`Test file not found: ${testFile}`);
+    }
+    const { flattened } = await loadAllRequirements(workspaceRoot);
+    const refs = await findRequirementsInFile(testFile);
+    // CLI-FIND-MAP-1.2: no references → explicit message
+    if (refs.length === 0) {
+        console.log(`No requirement() references found in "${testFile}".`);
+        return;
+    }
+    // CLI-FIND-MAP-1.0: line, ID, content for each reference
+    console.log(`Requirements referenced in "${testFile}":\n`);
+    for (const ref of refs) {
+        const req = getRequirementById(flattened, ref.requirementId);
+        const content = req
+            ? `${req.label}: ${req.content}`
+            : "(requirement not found)";
+        console.log(`  Line ${ref.line}: ${ref.requirementId} — ${content}`);
+    }
+}
+//# sourceMappingURL=requirements-for.js.map

package/dist/commands/review-test.d.ts

@@ -0,0 +1,2 @@
+export declare function reviewTestCommand(testFilePath: string): Promise<void>;
+//# sourceMappingURL=review-test.d.ts.map

package/dist/commands/review-test.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { DEFAULT_API_BASE_URL, fetchReviewTestFeedback, } from "../requirements/cloud-ai.js";
+import { formatRequirementTree, getRequirementTree, loadAllRequirements, } from "../requirements/index.js";
+import { getProjectCredentials } from "../utils/project-settings.js";
+export async function reviewTestCommand(testFilePath) {
+    const workspaceRoot = process.cwd();
+    const fullPath = resolve(workspaceRoot, testFilePath);
+    // CLI-REVIEW-1.5: missing file → error + non-zero exit
+    if (!existsSync(fullPath)) {
+        throw new Error(`File not found: ${testFilePath}`);
+    }
+    // CLI-REVIEW-1.6: must be a test file
+    if (!/\.(test|spec)\.(js|jsx|ts|tsx)$/.test(testFilePath)) {
+        throw new Error(`File must be a test file: *.{test,spec}.{js,jsx,ts,tsx} — got ${testFilePath}`);
+    }
+    const testFileContents = readFileSync(fullPath, "utf-8");
+    // CLI-REVIEW-1.0: collect every requirement(...) call site
+    const requirementIdMatches = testFileContents.matchAll(/requirement\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g);
+    const requirementIds = new Set();
+    for (const match of requirementIdMatches) {
+        requirementIds.add(match[1]);
+    }
+    // CLI-REVIEW-1.1: resolve references against the workspace and bundle trees
+    const { flattened } = await loadAllRequirements(workspaceRoot);
+    const rootToTestedIds = new Map();
+    for (const reqId of requirementIds) {
+        const req = flattened.find((r) => r.id === reqId || r.rootId === reqId);
+        if (req) {
+            if (!rootToTestedIds.has(req.rootId)) {
+                rootToTestedIds.set(req.rootId, new Set());
+            }
+            rootToTestedIds.get(req.rootId).add(reqId);
+        }
+    }
+    const requirements = [];
+    for (const [rootId, testedIds] of rootToTestedIds) {
+        const tree = getRequirementTree(flattened, rootId);
+        requirements.push({
+            id: rootId,
+            content: formatRequirementTree(tree),
+            testedIds: Array.from(testedIds).sort(),
+        });
+    }
+    // CLI-REVIEW-1.6: cloud credentials required
+    let projectId;
+    let projectSecret;
+    try {
+        const creds = getProjectCredentials(workspaceRoot);
+        projectId = creds.projectId;
+        projectSecret = creds.projectSecret;
+    }
+    catch (error) {
+        throw new Error(`Test review requires cloud credentials. Run \`dotrequirements link\` to connect this project to the cloud.\n` +
+            `(${error instanceof Error ? error.message : String(error)})`);
+    }
+    // CLI-REVIEW-1.2 / .3 / .4 / .7 / .8: dispatch to the hosted endpoint
+    const apiBaseUrl = process.env.DOTREQUIREMENTS_API_URL ?? DEFAULT_API_BASE_URL;
+    let feedback;
+    try {
+        feedback = await fetchReviewTestFeedback({
+            apiBaseUrl,
+            projectId,
+            projectSecret,
+            testFileContents,
+            requirements,
+        });
+    }
+    catch (error) {
+        throw new Error(`Test review failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.log(`Test Review Results for ${testFilePath}\n`);
+    console.log(feedback);
+}
+//# sourceMappingURL=review-test.js.map

package/dist/commands/search.d.ts

@@ -0,0 +1,6 @@
+interface SearchOptions {
+    regex?: boolean;
+}
+export declare function searchCommand(query: string, options: SearchOptions): Promise<void>;
+export {};
+//# sourceMappingURL=search.d.ts.map

package/dist/commands/search.js

@@ -0,0 +1,39 @@
+import { formatRequirementTree, getRequirementTree, loadAllRequirements, searchRequirements, } from "../requirements/index.js";
+export async function searchCommand(query, options) {
+    const { flattened } = await loadAllRequirements(process.cwd());
+    let results;
+    // CLI-FIND-SEARCH-1.1: --regex interprets query as case-insensitive regex
+    if (options.regex) {
+        let regex;
+        try {
+            regex = new RegExp(query, "i");
+        }
+        catch (error) {
+            // CLI-FIND-SEARCH-1.2: invalid regex → error + non-zero exit
+            throw new Error(`Invalid regular expression: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        results = flattened.filter((r) => regex.test(r.id) || regex.test(r.content) || regex.test(r.label));
+    }
+    else {
+        // CLI-FIND-SEARCH-1.0: text search across ID/content/label
+        results = searchRequirements(flattened, query);
+    }
+    // CLI-FIND-SEARCH-1.4: matches on child criteria bubble up to roots
+    const matchedRootIds = new Set(results.map((r) => r.rootId));
+    const rootResults = flattened.filter((r) => r.path.length === 0 && matchedRootIds.has(r.rootId));
+    // CLI-FIND-SEARCH-1.3: no matches → informative line
+    if (rootResults.length === 0) {
+        console.log(`No requirements found matching "${query}"${options.regex ? " (regex)" : ""}.`);
+        return;
+    }
+    // CLI-FIND-SEARCH-1.5: each result includes ID, source document, full tree
+    console.log(`Found ${rootResults.length} requirement(s) matching "${query}"${options.regex ? " (regex)" : ""}:\n`);
+    for (const r of rootResults) {
+        const tree = getRequirementTree(flattened, r.id);
+        console.log(`${r.id}`);
+        console.log(`  Source: ${r.documentTitle}`);
+        console.log(formatRequirementTree(tree));
+        console.log();
+    }
+}
+//# sourceMappingURL=search.js.map

package/dist/commands/style-check.d.ts

@@ -0,0 +1,7 @@
+interface StyleCheckOptions {
+    keys?: string[];
+    model?: string;
+}
+export declare function styleCheckCommand(filePath: string, options: StyleCheckOptions): Promise<void>;
+export {};
+//# sourceMappingURL=style-check.d.ts.map

package/dist/commands/style-check.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { DEFAULT_API_BASE_URL, fetchStyleCheckFeedback, } from "../requirements/cloud-ai.js";
+import { filterRequirementsByKeys } from "../requirements/index.js";
+import { getProjectCredentials } from "../utils/project-settings.js";
+export async function styleCheckCommand(filePath, options) {
+    const workspaceRoot = process.cwd();
+    const fullPath = resolve(workspaceRoot, filePath);
+    // CLI-STYLE-1.5: missing file → error + non-zero exit
+    if (!existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    // CLI-STYLE-1.0 / .1 / .6: file-type detection
+    const isRequirementsFile = filePath.endsWith(".requirements.md");
+    const isTestFile = /\.(test|spec)\.(js|jsx|ts|tsx)$/.test(filePath);
+    if (!isRequirementsFile && !isTestFile) {
+        throw new Error(`Unsupported file type: ${filePath}\n` +
+            `File must be a requirements file (*.requirements.md) or a test file (*.{test,spec}.{js,jsx,ts,tsx}).`);
+    }
+    const fileType = isRequirementsFile ? "requirements" : "test";
+    const fileContents = readFileSync(fullPath, "utf-8");
+    // CLI-STYLE-1.2 / .3: --keys handling
+    let fileContentsToCheck = fileContents;
+    let scopeNote = "";
+    if (options.keys && options.keys.length > 0) {
+        if (!isRequirementsFile) {
+            throw new Error(`--keys can only be used with requirements files (*.requirements.md), not test files.`);
+        }
+        const { filteredContent, foundKeys, missingKeys } = filterRequirementsByKeys(fileContents, options.keys);
+        if (foundKeys.length === 0) {
+            throw new Error(`None of the specified requirement keys were found in ${filePath}: ${options.keys.join(", ")}`);
+        }
+        fileContentsToCheck = filteredContent;
+        if (missingKeys.length > 0) {
+            scopeNote = `\nNote: Some specified keys were not found in the file: ${missingKeys.join(", ")}`;
+        }
+    }
+    // CLI-STYLE-1.7: credentials are required
+    let projectId;
+    let projectSecret;
+    try {
+        const creds = getProjectCredentials(workspaceRoot);
+        projectId = creds.projectId;
+        projectSecret = creds.projectSecret;
+    }
+    catch (error) {
+        throw new Error(`Style check requires cloud credentials. Run \`dotrequirements link\` to connect this project to the cloud.\n` +
+            `(${error instanceof Error ? error.message : String(error)})`);
+    }
+    // CLI-STYLE-1.4 / .8 / .9: dispatch to the hosted endpoint
+    const apiBaseUrl = process.env.DOTREQUIREMENTS_API_URL ?? DEFAULT_API_BASE_URL;
+    let feedback;
+    try {
+        feedback = await fetchStyleCheckFeedback({
+            apiBaseUrl,
+            projectId,
+            projectSecret,
+            fileContents: fileContentsToCheck,
+            fileType,
+            model: options.model,
+        });
+    }
+    catch (error) {
+        throw new Error(`Style check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const scopeLabel = options.keys && options.keys.length > 0
+        ? ` (${options.keys.join(", ")})`
+        : "";
+    console.log(`Style Check Results for ${filePath}${scopeLabel}\n`);
+    console.log(feedback);
+    if (scopeNote) {
+        console.log(scopeNote);
+    }
+}
+//# sourceMappingURL=style-check.js.map