@deftai/directive-core 0.55.0

package/dist/capacity/show.js

@@ -0,0 +1,387 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { recommendAutonomyLevel, resolveAutonomy } from "../policy/autonomy.js";
+import { CAPACITY_UNIT_COST, DEFAULT_CAPACITY_UNIT, resolveCapacityAllocation, } from "../policy/capacity.js";
+import { DEFAULT_PENDING_DECISIONS_THRESHOLD, pendingDecisionsNudgeLine, summarizeDecisionBacklog, } from "../policy/decisions.js";
+export const FORWARD_FOLDERS = ["pending", "active"];
+export const BACKWARD_FOLDER = "completed";
+export const UNASSIGNED_BUCKET = "unassigned";
+export const COST_COVERAGE_FLOOR = 0.5;
+const PARENT_KINDS = new Set(["epic", "phase"]);
+function parseIso(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        return null;
+    }
+    const parsed = new Date(value.replace("Z", "+00:00"));
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+function planHasChildren(plan) {
+    const refs = plan.references;
+    if (!Array.isArray(refs)) {
+        return false;
+    }
+    return refs.some((ref) => typeof ref === "object" &&
+        ref !== null &&
+        ref.type === "x-vbrief/plan");
+}
+function coerceCost(value) {
+    if (typeof value === "boolean") {
+        return null;
+    }
+    if (typeof value === "number" && value > 0) {
+        return value;
+    }
+    return null;
+}
+function recordWeight(kind, plan, metadata, allocation) {
+    if (PARENT_KINDS.has(kind)) {
+        if (planHasChildren(plan)) {
+            return 0;
+        }
+        const estimated = metadata.estimatedChildren;
+        if (typeof estimated === "number" && Number.isInteger(estimated) && estimated > 0) {
+            return estimated;
+        }
+        return allocation.default_epic_estimate;
+    }
+    return 1;
+}
+/** Derive a VbriefRecord from a single vBRIEF plan block. */
+export function classifyRecord(plan, folder, allocation, now) {
+    const metadata = typeof plan.metadata === "object" && plan.metadata !== null && !Array.isArray(plan.metadata)
+        ? plan.metadata
+        : {};
+    const kindRaw = metadata.kind;
+    const kind = typeof kindRaw === "string" && kindRaw.length > 0 ? kindRaw : "story";
+    const explicitBucket = metadata.capacityBucket;
+    const classified = typeof explicitBucket === "string" && explicitBucket.trim().length > 0;
+    let bucket;
+    if (classified) {
+        bucket = explicitBucket.trim();
+    }
+    else if (allocation.default_bucket) {
+        bucket = allocation.default_bucket;
+    }
+    else {
+        bucket = UNASSIGNED_BUCKET;
+    }
+    const weight = recordWeight(kind, plan, metadata, allocation);
+    let inWindow = false;
+    const rawCompletedAt = metadata.completedAt;
+    const completedAtPresent = typeof rawCompletedAt === "string" && rawCompletedAt.trim().length > 0;
+    if (folder === BACKWARD_FOLDER) {
+        const completedAt = parseIso(rawCompletedAt);
+        if (completedAt !== null) {
+            const ageDays = (now.getTime() - completedAt.getTime()) / (86400 * 1000);
+            inWindow = ageDays >= 0 && ageDays <= allocation.window_days;
+        }
+    }
+    const outcome = metadata.outcome;
+    const isRework = (typeof outcome === "string" && outcome.toLowerCase() === "rework") || metadata.rework === true;
+    return {
+        bucket,
+        kind,
+        weight,
+        folder,
+        classified,
+        in_window: inWindow,
+        completed_at_present: completedAtPresent,
+        is_rework: isRework,
+        cost: coerceCost(metadata.cost),
+    };
+}
+/** Yield (folder, plan) for every readable vBRIEF in lifecycle dirs. */
+export function iterVbriefPlans(vbriefRoot) {
+    const out = [];
+    for (const folder of [...FORWARD_FOLDERS, BACKWARD_FOLDER]) {
+        const folderPath = join(vbriefRoot, folder);
+        if (!existsSync(folderPath)) {
+            continue;
+        }
+        let names;
+        try {
+            names = readdirSync(folderPath);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names.sort()) {
+            if (!name.endsWith(".vbrief.json")) {
+                continue;
+            }
+            const child = join(folderPath, name);
+            try {
+                const data = JSON.parse(readFileSync(child, { encoding: "utf8" }));
+                const plan = typeof data === "object" && data !== null && !Array.isArray(data)
+                    ? data.plan
+                    : null;
+                if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+                    out.push([folder, plan]);
+                }
+            }
+            catch {
+                // skip unreadable
+            }
+        }
+    }
+    return out;
+}
+export function bucketDeficit(report, tally) {
+    const targetWeight = tally.target * report.total_backward;
+    return Math.round((targetWeight - tally.backward_weight) * 10000) / 10000;
+}
+function resolveEffectiveUnit(unitRequested, costEligible, costWithActual) {
+    if (unitRequested !== CAPACITY_UNIT_COST) {
+        return [unitRequested, false, null];
+    }
+    if (costEligible === 0) {
+        return [
+            DEFAULT_CAPACITY_UNIT,
+            true,
+            "unit:cost requested but no classified completions carry grounded cost actuals -- falling back to advisory vbrief-count (cost overlay: none/estimate-only)",
+        ];
+    }
+    const coverage = costWithActual / costEligible;
+    if (coverage < COST_COVERAGE_FLOOR) {
+        return [
+            DEFAULT_CAPACITY_UNIT,
+            true,
+            `unit:cost requested but only ${costWithActual}/${costEligible} (${Math.round(coverage * 100)}%) classified completions carry grounded cost actuals (< ${Math.round(COST_COVERAGE_FLOOR * 100)}% floor) -- falling back to advisory vbrief-count (cost overlay: none/estimate-only)`,
+        ];
+    }
+    return [CAPACITY_UNIT_COST, false, null];
+}
+/** Compute the CapacityReport for project_root (offline). */
+export function computeReport(projectRoot, options = {}) {
+    const now = options.now ?? new Date();
+    const allocation = options.allocation ?? resolveCapacityAllocation(projectRoot);
+    const vbriefRoot = join(resolve(projectRoot), "vbrief");
+    const records = iterVbriefPlans(vbriefRoot).map(([folder, plan]) => classifyRecord(plan, folder, allocation, now));
+    const tallies = new Map();
+    for (const bucket of allocation.buckets) {
+        tallies.set(bucket.bucket_id, {
+            bucket_id: bucket.bucket_id,
+            target: bucket.target,
+            forward_weight: 0,
+            backward_weight: 0,
+            rework_weight: 0,
+            cost_actual: null,
+        });
+    }
+    for (const record of records) {
+        if (!tallies.has(record.bucket)) {
+            tallies.set(record.bucket, {
+                bucket_id: record.bucket,
+                target: 0,
+                forward_weight: 0,
+                backward_weight: 0,
+                rework_weight: 0,
+                cost_actual: null,
+            });
+        }
+    }
+    let classifiedCompletions = 0;
+    let unclassifiedCompletions = 0;
+    let costEligible = 0;
+    let costWithActual = 0;
+    for (const record of records) {
+        const tally = tallies.get(record.bucket);
+        if (tally === undefined) {
+            continue;
+        }
+        if (FORWARD_FOLDERS.includes(record.folder)) {
+            tally.forward_weight += record.weight;
+        }
+        else if (record.folder === BACKWARD_FOLDER && record.in_window) {
+            tally.backward_weight += record.weight;
+            if (record.is_rework) {
+                tally.rework_weight += record.weight;
+            }
+            if (record.classified) {
+                classifiedCompletions += 1;
+                costEligible += 1;
+                if (record.cost !== null) {
+                    costWithActual += 1;
+                    tally.cost_actual = (tally.cost_actual ?? 0) + record.cost;
+                }
+            }
+        }
+    }
+    unclassifiedCompletions = records.filter((record) => record.folder === BACKWARD_FOLDER &&
+        !record.classified &&
+        (record.in_window || !record.completed_at_present)).length;
+    const totalForward = [...tallies.values()].reduce((sum, t) => sum + t.forward_weight, 0);
+    const totalBackward = [...tallies.values()].reduce((sum, t) => sum + t.backward_weight, 0);
+    const totalRework = [...tallies.values()].reduce((sum, t) => sum + t.rework_weight, 0);
+    const configuredIds = allocation.buckets.map((b) => b.bucket_id);
+    const extras = [...tallies.keys()].filter((id) => !configuredIds.includes(id)).sort();
+    const ordered = [...configuredIds, ...extras].map((id) => tallies.get(id));
+    const unitRequested = allocation.unit === DEFAULT_CAPACITY_UNIT || allocation.unit === CAPACITY_UNIT_COST
+        ? allocation.unit
+        : DEFAULT_CAPACITY_UNIT;
+    const [unitEffective, costFallback, costReason] = resolveEffectiveUnit(unitRequested, costEligible, costWithActual);
+    const advisoryReasons = [];
+    if (!allocation.configured) {
+        advisoryReasons.push("capacityAllocation not configured -- showing discovered buckets only");
+    }
+    const sampleShort = classifiedCompletions < allocation.min_sample_size;
+    if (sampleShort) {
+        advisoryReasons.push(`only ${classifiedCompletions} classified completion(s) in window (< minSampleSize=${allocation.min_sample_size}) -- deferring to ordering`);
+        if (allocation.configured && unclassifiedCompletions > 0) {
+            advisoryReasons.push(`${unclassifiedCompletions} completed vBRIEF(s) are unclassified -- run \`task capacity:backfill --apply\` (one-time) to classify history and activate capacity accounting`);
+        }
+    }
+    if (costFallback && costReason) {
+        advisoryReasons.push(costReason);
+    }
+    const backlog = summarizeDecisionBacklog(projectRoot, {
+        now,
+        window_days: allocation.window_days,
+    });
+    const reworkRate = totalBackward > 0 ? totalRework / totalBackward : 0;
+    const autonomyPolicy = resolveAutonomy(projectRoot);
+    const autonomy = autonomyPolicy.enabled
+        ? recommendAutonomyLevel(autonomyPolicy.default_level, {
+            override_rate: backlog.override_rate,
+            rework_rate: reworkRate,
+            sample_size: backlog.resolved_in_window,
+            p0_reversal: backlog.p0_reversal_in_window,
+            policy: autonomyPolicy,
+        })
+        : null;
+    return {
+        configured: allocation.configured,
+        source: allocation.source,
+        unit_requested: unitRequested,
+        unit_effective: unitEffective,
+        cost_fallback: costFallback,
+        cost_fallback_reason: costReason,
+        window_days: allocation.window_days,
+        min_sample_size: allocation.min_sample_size,
+        classified_completions: classifiedCompletions,
+        unclassified_completions: unclassifiedCompletions,
+        advisory_mode: sampleShort || !allocation.configured,
+        advisory_reasons: advisoryReasons,
+        buckets: ordered,
+        total_forward: totalForward,
+        total_backward: totalBackward,
+        policy_error: allocation.error,
+        pending_decisions: backlog.pending_count,
+        pending_by_kind: { ...backlog.by_kind },
+        pending_decisions_threshold: DEFAULT_PENDING_DECISIONS_THRESHOLD,
+        pending_nudge: pendingDecisionsNudgeLine(backlog.pending_count),
+        autonomy_enabled: autonomyPolicy.enabled,
+        autonomy,
+    };
+}
+function formatCost(value) {
+    if (value === null) {
+        return "none/estimate-only";
+    }
+    return value.toFixed(2);
+}
+function appendBacklogAndAutonomy(lines, report) {
+    lines.push(`  Pending human decisions: ${report.pending_decisions} (threshold ${report.pending_decisions_threshold})`);
+    if (Object.keys(report.pending_by_kind).length > 0) {
+        const kinds = Object.entries(report.pending_by_kind)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([kind, count]) => `${kind}=${count}`)
+            .join(", ");
+        lines.push(`    by kind: ${kinds}`);
+    }
+    if (report.pending_nudge.length > 0) {
+        lines.push(`  ${report.pending_nudge}`);
+    }
+    if (report.autonomy_enabled && report.autonomy !== null) {
+        const rec = report.autonomy;
+        lines.push(`  Autonomy dial (advisory-only): ${rec.current_level} -> ${rec.recommended_level} [${rec.action}]`);
+        lines.push(`    ${rec.rationale}`);
+    }
+}
+/** Render the CapacityReport as human-readable text. */
+export function renderReport(report) {
+    const lines = [];
+    lines.push("Capacity allocation (advisory, offline / filesystem-truth)");
+    lines.push(`  unit: ${report.unit_effective}` +
+        (report.cost_fallback ? ` (requested ${report.unit_requested}; cost fallback active)` : ""));
+    lines.push(`  window: trailing ${report.window_days}d | classified completions: ${report.classified_completions} (minSampleSize ${report.min_sample_size}) | source: ${report.source}`);
+    if (report.policy_error) {
+        lines.push(`  CONFIG ERROR: ${report.policy_error}`);
+    }
+    if (report.advisory_mode) {
+        lines.push("  MODE: ADVISORY -- deferring to selection ordering.");
+    }
+    for (const reason of report.advisory_reasons) {
+        lines.push(`    - ${reason}`);
+    }
+    appendBacklogAndAutonomy(lines, report);
+    if (report.buckets.length === 0) {
+        lines.push("  (no buckets configured and no classified work on disk)");
+        return lines.join("\n");
+    }
+    const header = `  ${"bucket".padEnd(16)} ${"target".padStart(7)} ${"fwd".padStart(7)} ${"back".padStart(7)} ${"deficit".padStart(8)} ${"rework".padStart(7)} ${"cost".padStart(18)}`;
+    lines.push(header);
+    lines.push(`  ${"-".repeat(header.length - 2)}`);
+    for (const tally of report.buckets) {
+        const deficit = bucketDeficit(report, tally);
+        lines.push(`  ${tally.bucket_id.padEnd(16)} ${`${(tally.target * 100).toFixed(1)}%`.padStart(7)} ${tally.forward_weight.toFixed(1).padStart(7)} ${tally.backward_weight.toFixed(1).padStart(7)} ${`${deficit >= 0 ? "+" : ""}${deficit.toFixed(2)}`.padStart(8)} ${tally.rework_weight.toFixed(1).padStart(7)} ${formatCost(tally.cost_actual).padStart(18)}`);
+    }
+    lines.push(`  ${"TOTAL".padEnd(16)} ${"".padStart(7)} ${report.total_forward.toFixed(1).padStart(7)} ${report.total_backward.toFixed(1).padStart(7)}`);
+    if (report.cost_fallback) {
+        lines.push("  Note: cost overlay shows none/estimate-only -- no grounded cost telemetry (out of scope / upstream-blocked, OQ2).");
+    }
+    return lines.join("\n");
+}
+/** Pure entry point: returns [exit_code, report, rendered_text]. */
+export function evaluate(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    try {
+        if (!statSync(root).isDirectory()) {
+            return [
+                2,
+                null,
+                `capacity_show: --project-root is not a directory: ${root}\n  Recovery: pass an existing project root.`,
+            ];
+        }
+    }
+    catch {
+        return [
+            2,
+            null,
+            `capacity_show: --project-root is not a directory: ${root}\n  Recovery: pass an existing project root.`,
+        ];
+    }
+    const report = computeReport(root, options);
+    return [0, report, renderReport(report)];
+}
+/** CLI entry point. */
+export function runCapacityShowCli(argv) {
+    let projectRoot = ".";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    exitCode: 2,
+                    stdout: "",
+                    stderr: "argument --project-root: expected one argument\n",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+    }
+    const [code, _report, message] = evaluate(projectRoot);
+    if (code === 0) {
+        return { exitCode: 0, stdout: `${message}\n`, stderr: "" };
+    }
+    return { exitCode: code, stdout: "", stderr: `${message}\n` };
+}
+//# sourceMappingURL=show.js.map

package/dist/check/index.d.ts

@@ -0,0 +1,3 @@
+export type { CheckOrchestratorSeams } from "./orchestrator.js";
+export { dispatchTaskCheck, isFrameworkSourceContext, resolveCheckTarget } from "./orchestrator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/check/index.js

@@ -0,0 +1,2 @@
+export { dispatchTaskCheck, isFrameworkSourceContext, resolveCheckTarget } from "./orchestrator.js";
+//# sourceMappingURL=index.js.map

package/dist/check/orchestrator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * check/orchestrator.ts -- Context-aware `task check` orchestrator (#1854).
+ *
+ * TypeScript port of scripts/_project_context.py dispatch_task_check().
+ * Detects whether we are running in the framework-source context or a
+ * vendored-consumer context (#1519) and dispatches to the appropriate
+ * aggregate Taskfile target.
+ *
+ * Exit codes (three-state, mirrors _project_context.py):
+ *   0 -- all gates passed
+ *   1 -- one or more gates failed
+ *   2 -- config error (missing args, task spawn error, etc.)
+ */
+/** Seams for test isolation (allow injecting a custom task runner). */
+export interface CheckOrchestratorSeams {
+    /** Override the `task` binary path (default: "task"). */
+    readonly taskBin?: string;
+    /** Override the spawnSync implementation for unit testing. */
+    readonly spawnFn?: (cmd: string, args: string[], opts: {
+        cwd: string;
+        stdio: string;
+    }) => {
+        status: number | null;
+        error?: Error;
+    };
+}
+/**
+ * Return true when running in the framework's own source checkout (#1519).
+ *
+ * Mirrors `is_framework_source_context` from _project_context.py:
+ * equality of lexical absolute roots is the stable distinction. We do NOT
+ * resolve symlinks here -- a consumer project may symlink `.deft/core` to a
+ * local framework checkout and should still run the consumer-safe gate.
+ */
+export declare function isFrameworkSourceContext(frameworkRoot: string, projectRoot: string): boolean;
+/**
+ * Select the Taskfile target for the given context.
+ *
+ * Mirrors _project_context.py::dispatch_task_check target selection.
+ */
+export declare function resolveCheckTarget(frameworkRoot: string, projectRoot: string): string;
+/**
+ * Dispatch to the context-appropriate `task check` aggregate target.
+ *
+ * Invokes `task [target] --taskfile <frameworkRoot>/Taskfile.yml` from the
+ * appropriate cwd so that go-task's `USER_WORKING_DIR` resolves correctly:
+ *   - framework-source: cwd = frameworkRoot (USER_WORKING_DIR = frameworkRoot ✓)
+ *   - consumer:         cwd = projectRoot  (USER_WORKING_DIR = projectRoot  ✓)
+ */
+export declare function dispatchTaskCheck(frameworkRoot: string, projectRoot: string, seams?: CheckOrchestratorSeams): number;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/check/orchestrator.js

@@ -0,0 +1,71 @@
+/**
+ * check/orchestrator.ts -- Context-aware `task check` orchestrator (#1854).
+ *
+ * TypeScript port of scripts/_project_context.py dispatch_task_check().
+ * Detects whether we are running in the framework-source context or a
+ * vendored-consumer context (#1519) and dispatches to the appropriate
+ * aggregate Taskfile target.
+ *
+ * Exit codes (three-state, mirrors _project_context.py):
+ *   0 -- all gates passed
+ *   1 -- one or more gates failed
+ *   2 -- config error (missing args, task spawn error, etc.)
+ */
+import { spawnSync } from "node:child_process";
+import { join, resolve } from "node:path";
+/**
+ * Return true when running in the framework's own source checkout (#1519).
+ *
+ * Mirrors `is_framework_source_context` from _project_context.py:
+ * equality of lexical absolute roots is the stable distinction. We do NOT
+ * resolve symlinks here -- a consumer project may symlink `.deft/core` to a
+ * local framework checkout and should still run the consumer-safe gate.
+ */
+export function isFrameworkSourceContext(frameworkRoot, projectRoot) {
+    return resolve(frameworkRoot) === resolve(projectRoot);
+}
+/**
+ * Select the Taskfile target for the given context.
+ *
+ * Mirrors _project_context.py::dispatch_task_check target selection.
+ */
+export function resolveCheckTarget(frameworkRoot, projectRoot) {
+    return isFrameworkSourceContext(frameworkRoot, projectRoot)
+        ? "check:framework-source"
+        : "check:consumer";
+}
+/**
+ * Dispatch to the context-appropriate `task check` aggregate target.
+ *
+ * Invokes `task [target] --taskfile <frameworkRoot>/Taskfile.yml` from the
+ * appropriate cwd so that go-task's `USER_WORKING_DIR` resolves correctly:
+ *   - framework-source: cwd = frameworkRoot (USER_WORKING_DIR = frameworkRoot ✓)
+ *   - consumer:         cwd = projectRoot  (USER_WORKING_DIR = projectRoot  ✓)
+ */
+export function dispatchTaskCheck(frameworkRoot, projectRoot, seams = {}) {
+    const resolvedFramework = resolve(frameworkRoot);
+    const resolvedProject = resolve(projectRoot);
+    const taskfilePath = join(resolvedFramework, "Taskfile.yml");
+    const taskBin = seams.taskBin ?? "task";
+    const target = resolveCheckTarget(resolvedFramework, resolvedProject);
+    const cwd = target === "check:framework-source" ? resolvedFramework : resolvedProject;
+    const spawn = seams.spawnFn ?? defaultSpawn;
+    const result = spawn(taskBin, [target, "--taskfile", taskfilePath], {
+        cwd,
+        stdio: "inherit",
+    });
+    if (result.error !== undefined) {
+        process.stderr.write(`check: failed to invoke task: ${result.error.message}\n`);
+        return 2;
+    }
+    return result.status ?? 1;
+}
+function defaultSpawn(cmd, args, opts) {
+    const result = spawnSync(cmd, args, {
+        cwd: opts.cwd,
+        stdio: opts.stdio,
+        env: { ...process.env },
+    });
+    return { status: result.status, error: result.error };
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/codebase/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEBASE_MAP_SCHEMA_PATH = "vbrief/schemas/codebase-map.schema.json";
+//# sourceMappingURL=constants.d.ts.map

package/dist/codebase/constants.js

@@ -0,0 +1,2 @@
+export const CODEBASE_MAP_SCHEMA_PATH = "vbrief/schemas/codebase-map.schema.json";
+//# sourceMappingURL=constants.js.map

package/dist/codebase/default-extractor.d.ts

@@ -0,0 +1,28 @@
+export declare const DEFAULT_PROVIDER_NAME = "directive-default-extractor";
+export declare const DEFAULT_PROVIDER_VERSION = "0.1";
+export declare const MAX_IMPORT_SCAN_BYTES = 262144;
+export declare const MAX_FILES_PER_MODULE = 100;
+export declare const MAX_EVIDENCE_PER_EDGE = 5;
+export declare const SKIP_DIRS: Set<string>;
+export declare const LANGUAGE_BY_SUFFIX: Readonly<Record<string, string>>;
+export declare const ENTRYPOINT_NAMES: Set<string>;
+export declare class CodeStructureConfigError extends Error {
+    constructor(message: string);
+}
+export declare function fileSha256(path: string): string;
+/** Return the authored codeStructure source path used by the default extractor. */
+export declare function defaultCodeStructurePath(projectRoot: string, codeStructurePath?: string): string;
+/** Build a deterministic tier-1 codebase-map artifact. */
+export declare function buildCodebaseMap(projectRoot: string, options?: {
+    codeStructurePath?: string;
+    fallbackReason?: string | null;
+}): Record<string, unknown>;
+export declare function configErrorToDict(path: string, error: CodeStructureConfigError | Error): Record<string, unknown>;
+export interface DefaultExtractorCliResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** CLI entry point. */
+export declare function runDefaultExtractorCli(argv: string[]): DefaultExtractorCliResult;
+//# sourceMappingURL=default-extractor.d.ts.map