@quantbrasil/cli 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/commands/screening.js

@@ -0,0 +1,361 @@
+import { readFile } from "node:fs/promises";
+import { screeningSortValues } from "../vendor/core/capabilities/index.js";
+import { invokeCliCapability } from "../cli/client.js";
+import { createCliValidationError } from "../cli/errors.js";
+import { createTerminalTheme } from "../cli/terminal.js";
+export function registerScreeningCommands(program, context = {}) {
+    const screeningCommand = program
+        .command("screening")
+        .description("Executa screening de indicadores em universos salvos");
+    screeningCommand
+        .command("universes")
+        .description("Lista universos salvos disponíveis para screening de indicadores")
+        .option("--json", "Exibe saída JSON")
+        .action(async (options) => {
+        await runScreeningUniversesCommand(options, context);
+    });
+    screeningCommand
+        .command("indicators")
+        .description("Lista indicadores disponíveis para screening")
+        .option("--json", "Exibe saída JSON")
+        .action(async (options) => {
+        await runScreeningIndicatorsCommand(options, context);
+    });
+    screeningCommand
+        .command("run")
+        .description("Executa screening de indicadores a partir de um ScreenerRequest JSON")
+        .option("--system <slug>", "Slug da carteira do sistema")
+        .option("--watchlist <id>", "ID da watchlist")
+        .option("--holding <id>", "ID da carteira")
+        .requiredOption("--query-file <path>", "Caminho para um ScreenerRequest JSON completo, ou - para stdin")
+        .option("--limit <limit>", "Sobrescreve o limit de topo do ScreenerRequest")
+        .option("--sort <sort>", "Sobrescreve o sort de topo do ScreenerRequest")
+        .option("--json", "Exibe saída JSON")
+        .action(async (options) => {
+        await runScreeningRunCommand(options, context);
+    });
+}
+export async function runScreeningUniversesCommand(options, context = {}) {
+    const stdout = context.io?.stdout ?? process.stdout;
+    const theme = createTerminalTheme(stdout, context.env ?? process.env);
+    const response = await invokeCliCapability({
+        capability: "screening.universes",
+        env: context.env,
+        fetch: context.fetch,
+    });
+    if (options.json) {
+        stdout.write(`${JSON.stringify(response.data, null, 2)}\n`);
+        return;
+    }
+    stdout.write(`${formatScreeningUniversesHuman(response.data, theme)}\n`);
+}
+export async function runScreeningIndicatorsCommand(options, context = {}) {
+    const stdout = context.io?.stdout ?? process.stdout;
+    const theme = createTerminalTheme(stdout, context.env ?? process.env);
+    const response = await invokeCliCapability({
+        capability: "screening.indicators",
+        env: context.env,
+        fetch: context.fetch,
+    });
+    if (options.json) {
+        stdout.write(`${JSON.stringify(response.data, null, 2)}\n`);
+        return;
+    }
+    stdout.write(`${formatScreeningIndicatorsHuman(response.data, theme)}\n`);
+}
+export async function runScreeningRunCommand(options, context = {}) {
+    const stdout = context.io?.stdout ?? process.stdout;
+    const theme = createTerminalTheme(stdout, context.env ?? process.env);
+    const input = await buildScreeningRunInput(options);
+    const response = await invokeCliCapability({
+        capability: "screening.run",
+        input,
+        env: context.env,
+        fetch: context.fetch,
+    });
+    if (options.json) {
+        stdout.write(`${JSON.stringify(response.data, null, 2)}\n`);
+        return;
+    }
+    stdout.write(`${formatScreeningRunHuman(response.data, theme)}\n`);
+}
+export async function buildScreeningRunInput(options) {
+    const selector = parseScreeningSelector(options);
+    const queryFile = normalizeRequiredPath(options.queryFile);
+    const request = await readScreenerRequest(queryFile);
+    if (options.limit !== undefined) {
+        request.limit = parseLimitOption(options.limit);
+    }
+    if (options.sort !== undefined) {
+        request.sort = parseSortOption(options.sort);
+    }
+    return {
+        ...selector,
+        request,
+    };
+}
+export function formatScreeningUniversesHuman(data, theme = createTerminalTheme(process.stdout)) {
+    const lines = [
+        theme.label("Universos de screening"),
+        "",
+        `${theme.label("Total:")} ${formatInteger(data.total)}`,
+    ];
+    appendUniverseGroup(lines, theme, "Carteiras do sistema", data.system);
+    appendUniverseGroup(lines, theme, "Watchlists", data.watchlists);
+    appendUniverseGroup(lines, theme, "Carteiras", data.holdings);
+    return lines.join("\n");
+}
+export function formatScreeningIndicatorsHuman(data, theme = createTerminalTheme(process.stdout)) {
+    const lines = [
+        theme.label("Indicadores de screening"),
+        "",
+        `${theme.label("Total:")} ${formatInteger(data.indicators.length)}`,
+        `${theme.label("Operadores:")} ${data.operators.join(", ")}`,
+    ];
+    for (const indicator of data.indicators) {
+        lines.push("");
+        lines.push(`${theme.bold(indicator.name)} ${theme.dim("-")} ${indicator.display_name}`);
+        lines.push(`  ${indicator.description}`);
+        lines.push(`  ${theme.label("Timeframes:")} ${indicator.timeframes.join(", ")}`);
+        if (indicator.params.length > 0) {
+            lines.push(`  ${theme.label("Parâmetros:")}`);
+            for (const param of indicator.params) {
+                lines.push(`    ${formatIndicatorParam(param)}`);
+            }
+        }
+        if (indicator.examples.length > 0) {
+            lines.push(`  ${theme.label("Exemplos:")} ${indicator.examples
+                .map(example => example.label)
+                .join(", ")}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatScreeningRunHuman(data, theme = createTerminalTheme(process.stdout)) {
+    const lines = [
+        theme.label("Screening de indicadores"),
+        "",
+        `${theme.bold(data.universe.name)} ${theme.dim(`- ${formatUniverseKind(data.universe.kind)}`)}`,
+        `${theme.label("Seletor:")} ${formatUniverseSelector(data.universe)}`,
+        `${theme.label("Ativos encontrados:")} ${formatInteger(data.result.count)}`,
+    ];
+    if (data.summary_markdown.trim()) {
+        lines.push("");
+        lines.push(data.summary_markdown);
+    }
+    if (data.result.results.length === 0) {
+        lines.push("");
+        lines.push("Nenhum ativo encontrado.");
+        return lines.join("\n");
+    }
+    const indicatorKeys = collectIndicatorKeys(data.result.results);
+    const visibleIndicatorKeys = indicatorKeys.slice(0, 4);
+    lines.push("");
+    lines.push(formatResultTable(data.result.results, visibleIndicatorKeys, theme));
+    if (indicatorKeys.length > visibleIndicatorKeys.length) {
+        lines.push("");
+        lines.push("Use --json para inspecionar todas as colunas de indicadores.");
+    }
+    return lines.join("\n");
+}
+function parseScreeningSelector(options) {
+    const selectorCount = [
+        options.system,
+        options.watchlist,
+        options.holding,
+    ].filter(value => value !== undefined).length;
+    if (selectorCount !== 1) {
+        throw createCliValidationError("Use exatamente um seletor: --system, --watchlist ou --holding.");
+    }
+    if (options.system !== undefined) {
+        const systemSlug = options.system.trim().toLowerCase();
+        if (!systemSlug) {
+            throw createCliValidationError("O slug da carteira do sistema é obrigatório.");
+        }
+        return { system_slug: systemSlug };
+    }
+    if (options.watchlist !== undefined) {
+        return {
+            watchlist_id: parsePositiveInteger(options.watchlist, "ID da watchlist"),
+        };
+    }
+    return {
+        holding_id: parsePositiveInteger(String(options.holding), "ID da carteira"),
+    };
+}
+function normalizeRequiredPath(value) {
+    const normalized = value?.trim();
+    if (!normalized) {
+        throw createCliValidationError("Use --query-file com um caminho JSON ou -.");
+    }
+    return normalized;
+}
+async function readScreenerRequest(path) {
+    let text;
+    try {
+        text = path === "-" ? await readStdinText() : await readFile(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw createCliValidationError(`Não foi possível ler o JSON da consulta: ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw createCliValidationError(`Não foi possível interpretar o JSON da consulta: ${message}`);
+    }
+    if (!isJsonRecord(parsed)) {
+        throw createCliValidationError("O JSON da consulta deve ser um objeto.");
+    }
+    return parsed;
+}
+async function readStdinText() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    }
+    return chunks.join("");
+}
+function parseLimitOption(value) {
+    const parsed = parsePositiveInteger(value, "limite");
+    if (parsed > 500) {
+        throw createCliValidationError("O limite deve ser um inteiro entre 1 e 500.");
+    }
+    return parsed;
+}
+function parsePositiveInteger(value, fieldName) {
+    const normalized = value.trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw createCliValidationError(`O valor de ${fieldName} deve ser um inteiro positivo.`);
+    }
+    const parsed = Number(normalized);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw createCliValidationError(`O valor de ${fieldName} deve ser um inteiro positivo.`);
+    }
+    return parsed;
+}
+function parseSortOption(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!screeningSortValues.includes(normalized)) {
+        throw createCliValidationError("A ordenação deve ser uma destas opções: price, ticker.");
+    }
+    return normalized;
+}
+function appendUniverseGroup(lines, theme, title, universes) {
+    lines.push("");
+    lines.push(`${theme.label(title)} ${theme.dim(`(${formatInteger(universes.length)})`)}`);
+    if (universes.length === 0) {
+        lines.push("  nenhum item");
+        return;
+    }
+    for (const universe of universes) {
+        lines.push(`  ${theme.bold(formatUniverseSelector(universe))} ${theme.dim("-")} ${universe.name}`);
+        lines.push(`    ${theme.label("Ativos:")} ${formatInteger(universe.symbol_count)}`);
+    }
+}
+function formatUniverseSelector(universe) {
+    if (universe.kind === "SYSTEM") {
+        return `--system ${universe.slug ?? universe.id}`;
+    }
+    if (universe.kind === "WATCHLIST") {
+        return `--watchlist ${universe.id}`;
+    }
+    return `--holding ${universe.id}`;
+}
+function formatUniverseKind(kind) {
+    if (kind === "SYSTEM") {
+        return "Carteira do sistema";
+    }
+    if (kind === "WATCHLIST") {
+        return "Watchlist";
+    }
+    return "Carteira";
+}
+function formatIndicatorParam(param) {
+    const details = [param.type];
+    if (param.required) {
+        details.push("obrigatório");
+    }
+    if (param.default !== null) {
+        details.push(`padrão ${formatScalar(param.default)}`);
+    }
+    if (param.enum_values !== null && param.enum_values.length > 0) {
+        details.push(`opções ${param.enum_values.join("|")}`);
+    }
+    return `${param.name}: ${details.join(", ")} - ${param.description}`;
+}
+function formatScalar(value) {
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+function collectIndicatorKeys(results) {
+    const keys = [];
+    const seen = new Set();
+    for (const result of results) {
+        for (const key of Object.keys(result.indicators)) {
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            keys.push(key);
+        }
+    }
+    return keys;
+}
+function formatResultTable(results, indicatorKeys, theme) {
+    const headers = [
+        "Ativo",
+        "Preço",
+        ...indicatorKeys.map(key => truncate(results[0]?.indicators[key]?.display_name ?? key, 18)),
+    ];
+    const rows = results.map(result => [
+        result.ticker,
+        formatNumber(result.price),
+        ...indicatorKeys.map(key => formatIndicatorValue(result.indicators[key])),
+    ]);
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map(row => row[index]?.length ?? 0)));
+    const lines = [
+        headers
+            .map((header, index) => header.padEnd(widths[index] ?? 0))
+            .join("  "),
+        widths.map(width => "-".repeat(width)).join("  "),
+    ];
+    for (const row of rows) {
+        lines.push(row.map((value, index) => value.padEnd(widths[index] ?? 0)).join("  "));
+    }
+    return lines
+        .map((line, index) => (index === 0 ? theme.label(line) : line))
+        .join("\n");
+}
+function formatIndicatorValue(indicator) {
+    if (!indicator) {
+        return "n/d";
+    }
+    const formatted = formatNumber(indicator.value);
+    if (!indicator.unit) {
+        return formatted;
+    }
+    return indicator.unit === "%"
+        ? `${formatted}%`
+        : `${formatted} ${indicator.unit}`;
+}
+function formatInteger(value) {
+    return new Intl.NumberFormat("en-US", {
+        maximumFractionDigits: 0,
+    }).format(value);
+}
+function formatNumber(value) {
+    return new Intl.NumberFormat("en-US", {
+        maximumFractionDigits: 4,
+    }).format(value);
+}
+function truncate(value, maxLength) {
+    return value.length <= maxLength
+        ? value
+        : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/commands/skills.js

@@ -4,18 +4,18 @@ import { createTerminalTheme } from "../cli/terminal.js";
 export function registerSkillsCommands(program, context = {}) {
     const skillsCommand = program
         .command("skills")
-        .description("Manage bundled public skills");
+        .description("Gerencia skills públicas empacotadas");
     skillsCommand
         .command("install")
-        .description("Install bundled QuantBrasil skills into detected agent clients")
-        .option("--all", "Install all bundled public QuantBrasil skills")
+        .description("Instala a skill pública do QuantBrasil nos clientes de agente detectados")
+        .option("--all", "Instala todas as skills públicas empacotadas")
         .action(async (options) => {
         await runSkillsInstallCommand(options, context);
     });
 }
 export async function runSkillsInstallCommand(options, context = {}) {
     if (!options.all) {
-        throw createCliValidationError("Use --all to install the bundled QuantBrasil skill into detected agent clients.");
+        throw createCliValidationError("Use --all para instalar a skill QuantBrasil nos clientes de agente detectados.");
     }
     const stdout = context.io?.stdout ?? process.stdout;
     const theme = createTerminalTheme(stdout, context.env ?? process.env);
@@ -23,15 +23,15 @@ export async function runSkillsInstallCommand(options, context = {}) {
     stdout.write(`${formatSkillsInstallResult(result, theme)}\n`);
 }
 export function formatSkillsInstallResult(result, theme = createTerminalTheme(process.stdout)) {
-    const lines = [theme.label("Installed QuantBrasil skill"), ""];
+    const lines = [theme.label("Skill QuantBrasil instalada"), ""];
     for (const target of result.installed) {
         lines.push(`${theme.success(target.label)} ${theme.dim(`→ ${target.installDir}`)}`);
     }
     if (result.skipped.length > 0) {
         lines.push("");
-        lines.push(theme.label("Skipped"));
+        lines.push(theme.label("Ignorados"));
         for (const target of result.skipped) {
-            lines.push(`${theme.dim(`${target.label} not detected at ${target.rootDir}`)}`);
+            lines.push(`${theme.dim(`${target.label} não detectado em ${target.rootDir}`)}`);
         }
     }
     return lines.join("\n");

package/dist/commands/update.d.ts

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+import { type TerminalWriter } from "../cli/terminal.js";
+export interface UpdateCommandIO {
+    stdout: TerminalWriter;
+}
+export interface UpdateCommandOptions {
+    yes?: boolean;
+}
+export interface UpdateCommandResult {
+    stdout: string;
+    stderr: string;
+}
+export type UpdateCommandRunner = (command: string, args: readonly string[], env: NodeJS.ProcessEnv) => Promise<UpdateCommandResult>;
+export interface UpdateCommandContext {
+    io?: UpdateCommandIO;
+    env?: NodeJS.ProcessEnv;
+    prompt?: (promptLabel: string) => Promise<string>;
+    commandRunner?: UpdateCommandRunner;
+    currentVersion?: string;
+}
+export declare function registerUpdateCommand(program: Command, context?: UpdateCommandContext): void;
+export declare function runUpdateCommand(options: UpdateCommandOptions, context?: UpdateCommandContext): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../src/commands/update.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG9E,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAElC,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,eAAe,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAClD,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAQN;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CA2Cf"}

package/dist/commands/update.js

@@ -0,0 +1,209 @@
+import { spawn } from "node:child_process";
+import { createCliConfigError } from "../cli/errors.js";
+import { promptForConfirmation } from "../cli/prompt.js";
+import { getBundledSkillInstallState, installBundledSkillEverywhere, } from "../cli/skills.js";
+import { createTerminalTheme } from "../cli/terminal.js";
+import { formatSkillsInstallResult } from "./skills.js";
+const CLI_PACKAGE_SPEC = "@quantbrasil/cli@beta";
+export function registerUpdateCommand(program, context = {}) {
+    program
+        .command("update")
+        .description("Atualiza o pacote global e a skill pública do QuantBrasil")
+        .option("--yes", "Atualiza sem confirmação interativa")
+        .action(async (options) => {
+        await runUpdateCommand(options, context);
+    });
+}
+export async function runUpdateCommand(options, context = {}) {
+    const env = context.env ?? process.env;
+    const stdout = context.io?.stdout ?? process.stdout;
+    const theme = createTerminalTheme(stdout, env);
+    const runner = context.commandRunner ?? runExternalCommand;
+    const currentVersion = context.currentVersion ?? "0.0.0";
+    const latestVersion = await getLatestBetaVersion(runner, env);
+    const cliNeedsUpdate = compareVersions(currentVersion, latestVersion) < 0;
+    const skillState = await getBundledSkillInstallState(env);
+    const skillNeedsUpdate = skillState.needsInstall;
+    if (!cliNeedsUpdate && !skillNeedsUpdate) {
+        stdout.write(`${theme.success("QuantBrasil CLI já está atualizado.")}\n`);
+        return;
+    }
+    stdout.write(`${formatUpdatePlan({
+        currentVersion,
+        latestVersion,
+        cliNeedsUpdate,
+        skillState,
+    }, theme)}\n`);
+    if (!(await shouldContinue(options, context))) {
+        stdout.write(`${theme.warning("Atualização cancelada.")}\n`);
+        return;
+    }
+    if (cliNeedsUpdate) {
+        await runner("npm", ["install", "-g", CLI_PACKAGE_SPEC], env);
+        await runner("quantbrasil", ["skills", "install", "--all"], env);
+        stdout.write(`${theme.success("Atualização concluída.")}\n`);
+        return;
+    }
+    const skillInstallResult = await installBundledSkillEverywhere(env);
+    stdout.write(`${formatSkillsInstallResult(skillInstallResult, theme)}\n`);
+    stdout.write(`${theme.success("Atualização concluída.")}\n`);
+}
+function formatUpdatePlan(data, theme) {
+    const lines = [
+        theme.label("Atualização do QuantBrasil CLI"),
+        "",
+        `${theme.label("Versão instalada:")} ${data.currentVersion}`,
+        `${theme.label("Versão beta publicada:")} ${data.latestVersion}`,
+    ];
+    const skillTargets = data.skillState.targets.filter(target => target.status === "missing" || target.status === "stale");
+    if (skillTargets.length > 0) {
+        lines.push(`${theme.label("Skills:")} ${skillTargets.length} alvo(s) precisam ser atualizados`);
+        for (const target of skillTargets) {
+            lines.push(`  ${target.label}: ${formatSkillStatus(target.status)} ${theme.dim(`(${target.installDir})`)}`);
+        }
+    }
+    else {
+        lines.push(`${theme.label("Skills:")} já estão atualizadas`);
+    }
+    lines.push("");
+    lines.push(theme.label("Ações"));
+    if (data.cliNeedsUpdate) {
+        lines.push(`  npm install -g ${CLI_PACKAGE_SPEC}`);
+        lines.push("  quantbrasil skills install --all");
+    }
+    else if (skillTargets.length > 0) {
+        lines.push("  quantbrasil skills install --all");
+    }
+    return lines.join("\n");
+}
+async function shouldContinue(options, context) {
+    if (options.yes) {
+        return true;
+    }
+    if (context.prompt) {
+        return parseConfirmationAnswer(await context.prompt("Atualizar agora? [s/N] "));
+    }
+    return promptForConfirmation("Atualizar agora? [s/N] ");
+}
+function formatSkillStatus(status) {
+    if (status === "missing") {
+        return "não instalada";
+    }
+    if (status === "stale") {
+        return "desatualizada";
+    }
+    return status;
+}
+function parseConfirmationAnswer(answer) {
+    return ["s", "sim", "y", "yes"].includes(answer.trim().toLowerCase());
+}
+async function getLatestBetaVersion(runner, env) {
+    const result = await runner("npm", ["view", CLI_PACKAGE_SPEC, "version"], env);
+    const version = result.stdout.trim();
+    if (!version) {
+        throw createCliConfigError(`Não foi possível resolver a versão publicada de ${CLI_PACKAGE_SPEC}.`);
+    }
+    return version;
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    for (let index = 0; index < 3; index += 1) {
+        const diff = (parsedLeft.main[index] ?? 0) - (parsedRight.main[index] ?? 0);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    if (parsedLeft.prerelease.length === 0 &&
+        parsedRight.prerelease.length === 0) {
+        return 0;
+    }
+    if (parsedLeft.prerelease.length === 0) {
+        return 1;
+    }
+    if (parsedRight.prerelease.length === 0) {
+        return -1;
+    }
+    const length = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = parsedLeft.prerelease[index];
+        const rightPart = parsedRight.prerelease[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const diff = comparePrereleasePart(leftPart, rightPart);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+function parseVersion(version) {
+    const [mainVersion = "0.0.0", prerelease = ""] = version
+        .trim()
+        .replace(/^v/, "")
+        .split("-");
+    const mainParts = mainVersion.split(".").map(part => Number(part));
+    const main = [
+        normalizeVersionPart(mainParts[0]),
+        normalizeVersionPart(mainParts[1]),
+        normalizeVersionPart(mainParts[2]),
+    ];
+    return {
+        main,
+        prerelease: prerelease ? prerelease.split(".") : [],
+    };
+}
+function normalizeVersionPart(part) {
+    return Number.isFinite(part) ? Number(part) : 0;
+}
+function comparePrereleasePart(left, right) {
+    const leftNumber = Number(left);
+    const rightNumber = Number(right);
+    const leftIsNumeric = /^\d+$/.test(left);
+    const rightIsNumeric = /^\d+$/.test(right);
+    if (leftIsNumeric && rightIsNumeric) {
+        return leftNumber - rightNumber;
+    }
+    if (leftIsNumeric) {
+        return -1;
+    }
+    if (rightIsNumeric) {
+        return 1;
+    }
+    return left.localeCompare(right);
+}
+function runExternalCommand(command, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", chunk => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", chunk => {
+            stderr += chunk;
+        });
+        child.on("error", error => {
+            reject(createCliConfigError(`Não foi possível executar ${command}: ${error.message}`));
+        });
+        child.on("close", code => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+                return;
+            }
+            reject(createCliConfigError([
+                `${command} ${args.join(" ")} falhou com exit ${code}.`,
+                stderr.trim() || stdout.trim(),
+            ]
+                .filter(Boolean)
+                .join("\n")));
+        });
+    });
+}

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export * from "./commands/capabilities.js";
 export * from "./commands/init.js";
 export * from "./commands/market.js";
 export * from "./commands/portfolios.js";
+export * from "./commands/screening.js";
 export * from "./commands/skills.js";
 export * from "./commands/status.js";
+export * from "./commands/update.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -8,5 +8,7 @@ export * from "./commands/capabilities.js";
 export * from "./commands/init.js";
 export * from "./commands/market.js";
 export * from "./commands/portfolios.js";
+export * from "./commands/screening.js";
 export * from "./commands/skills.js";
 export * from "./commands/status.js";
+export * from "./commands/update.js";

package/dist/vendor/core/capabilities/index.d.ts

@@ -2,6 +2,7 @@ export * from "./types.js";
 export * from "./shared.js";
 export * from "./market.js";
 export * from "./assets.js";
+export * from "./screening.js";
 export * from "./portfolios.js";
 export * from "./registry.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/vendor/core/capabilities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/capabilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/capabilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}