artemys 0.3.1 → 0.3.3

package/dist/cli/index.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
 import { CoffeeShopClient } from "../coffeeshop/index.js";
 import { AgentCardSchema, DiscoveryQuerySchema, } from "../discovery/index.js";
-import { ConversationTracker, ProfileStore, SqliteMcpPersistence, createPersistentConversationTracker, createPersistentProfileStore, startArtemysMcpServer, } from "../mcp-server/index.js";
-import { registerMessagingTools } from "../mcp-server/tools/messaging.js";
-import { registerTalentTools } from "../mcp-server/tools/talent.js";
-const DEFAULT_COFFEESHOP_URL = "https://coffeeshop.artemys.ai";
-const DEFAULT_MAX_TRACKED_CONVERSATIONS = 1_000;
-const DEFAULT_CONVERSATION_TTL_MS = 24 * 60 * 60 * 1000;
+import { ConversationTracker, DEFAULT_CONVERSATION_TTL_MS, DEFAULT_MAX_TRACKED_CONVERSATIONS, ProfileStore, SqliteMcpPersistence, createPersistentConversationTracker, createPersistentProfileStore, startArtemysMcpServer, } from "../mcp-server/index.js";
+import { CandidateSnapshotSchema } from "../protocol/index.js";
+import { checkInbox, respondToMessage } from "../mcp-server/tools/messaging.js";
+import { searchOpportunities, expressInterest, updateProfile, getMyApplications } from "../mcp-server/tools/talent.js";
+import { getConfigPath, getFlagString, loadConfig, resolveAgentCardPath, resolveApiKey, resolveCoffeeShopUrl, saveConfig, } from "./config.js";
 function parseArgs(argv) {
     const positionals = [];
     const flags = {};
@@ -44,10 +43,6 @@ function parseArgs(argv) {
     }
     return { positionals, flags };
 }
-function getFlagString(flags, key) {
-    const value = flags[key];
-    return typeof value === "string" ? value : undefined;
-}
 function getFlagBoolean(flags, key) {
     const value = flags[key];
     if (typeof value === "boolean") {
@@ -85,39 +80,51 @@ function getPersistOption(flags) {
     }
     return undefined;
 }
-function getCsvFlagList(flags, key) {
-    const value = getFlagString(flags, key);
-    if (!value) {
-        return undefined;
-    }
-    const items = value
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-    return items.length > 0 ? items : undefined;
+async function outputJson(data, outputPath) {
+    const json = JSON.stringify(data, null, 2);
+    if (outputPath) {
+        await writeFile(outputPath, json + "\n", "utf-8");
+        console.log(`Written to ${outputPath}`);
+    }
+    else {
+        console.log(json);
+    }
 }
 function printHelp() {
     console.log(`
 artemys - Protocol + Coffee Shop + MCP Server SDK CLI
 
 Commands:
+  start        Initialize agent identity and register with Coffee Shop
+  whoami       Show current agent identity and hub status
+  doctor       Run diagnostics on agent setup
   mcp-server   Start Artemys MCP server
   talent       Candidate talent workflow commands
   register     Register an agent card with Coffee Shop
   discover     Discover agents via Coffee Shop
   rotate-key   Rotate Coffee Shop API key
+  parse-resume Parse a resume file (PDF or text) into structured JSON via LLM
+  to-card      Convert a FullResume JSON to an anonymous CandidateCard
   version      Show CLI version
   help         Show this help message
 
 Examples:
-  artemys mcp-server --agent-card ./agent-card.json
+  artemys start
+  artemys start --display-name "My Agent" --role candidate --handle my-agent
+  artemys whoami
+  artemys doctor
+  artemys mcp-server
   artemys mcp-server --agent-card ./agent-card.json --persist
+  artemys mcp-server --transport sse --mcp-token my-secret
   artemys register --agent-card ./agent-card.json
-  artemys discover --requester-agent-id agent-123 --role talent_agent
-  artemys talent search --agent-card ./agent-card.json --limit 20
-  artemys talent apply --agent-card ./agent-card.json --job-id job-123 --persist
-  artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --persist
-  artemys rotate-key --agent-id agent-123 --api-key old-key
+  artemys discover --requester-agent-id @my-agent --role talent_agent
+  artemys talent search --skills TypeScript,React --remote --location "San Francisco"
+  artemys talent apply --job-id job-123 --persist
+  artemys talent profile --profile-file ./candidate-profile.json --persist
+  artemys talent respond --message-id msg-456 --content '{"text":"Sounds great"}'
+  artemys rotate-key --agent-id @my-agent --api-key old-key
+  artemys parse-resume ./resume.pdf --provider anthropic --api-key sk-...  # or set ANTHROPIC_API_KEY
+  artemys to-card ./resume.json --output ./card.json
 `);
 }
 function printTalentHelp() {
@@ -125,20 +132,26 @@ function printTalentHelp() {
 artemys talent - Candidate talent workflow commands
 
 Subcommands:
-  search   Search for matching job opportunities
-  apply    Submit an application for a job posting
-  status   Check inbox messages
-  profile  Update stored candidate profile
-  help     Show this help message
+  whoami        Show current candidate profile summary
+  search        Search for matching job opportunities
+  apply         Submit an application for a job posting
+  applications  List your submitted applications
+  status        Check inbox messages
+  respond       Reply to a message in your inbox
+  profile       Update stored candidate profile
+  help          Show this help message
 
 Examples:
-  artemys talent search --agent-card ./agent-card.json --limit 20
+  artemys talent whoami --agent-card ./agent-card.json --persist
+  artemys talent search --agent-card ./agent-card.json --skills TypeScript,React --remote --limit 20
   artemys talent apply --agent-card ./agent-card.json --job-id job-123 --match-reasoning "Strong backend fit"
+  artemys talent applications --status pending --agent-card ./agent-card.json
   artemys talent status --agent-card ./agent-card.json --unread-only --persist
+  artemys talent respond --agent-card ./agent-card.json --message-id msg-456 --content '{"text":"Interested, available next week"}'
   artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --sync-agent-card --persist ~/.artemys/state.db
 
 Common flags:
-  --agent-card <path>      Required for all talent subcommands except help
+  --agent-card <path>      Path to agent card (optional if 'artemys start' was run)
   --coffeeshop-url <url>   Override Coffee Shop base URL
   --persist [path]         Persist profile + conversations to SQLite (default: ~/.artemys/state.db)
 `);
@@ -148,13 +161,21 @@ async function readAgentCardFromPath(pathValue) {
     const parsed = JSON.parse(raw);
     return AgentCardSchema.parse(parsed);
 }
+async function resolveAndReadAgentCard(flags) {
+    const cardPath = resolveAgentCardPath(flags);
+    if (!cardPath) {
+        throw new Error("No agent card found. Run 'artemys start' to get started, or use --agent-card <path>.");
+    }
+    return readAgentCardFromPath(cardPath);
+}
 function buildNetworkDeps(args, agentCard) {
-    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
-    const hasCoffeeShopApiKey = typeof process.env.ARTEMYS_COFFEESHOP_API_KEY === "string" &&
-        process.env.ARTEMYS_COFFEESHOP_API_KEY.length > 0;
+    const config = loadConfig();
+    const coffeeShopUrl = resolveCoffeeShopUrl(args.flags, config);
+    const apiKey = resolveApiKey(config);
+    const hasCoffeeShopApiKey = typeof apiKey === "string" && apiKey.length > 0;
     const coffeeShopClient = new CoffeeShopClient({
         baseUrl: coffeeShopUrl,
-        apiKey: process.env.ARTEMYS_COFFEESHOP_API_KEY,
+        apiKey,
         agentId: agentCard.agent_id,
     });
     return {
@@ -188,48 +209,100 @@ function buildTalentState(flags) {
         },
     };
 }
-function buildTalentToolHandlers(deps) {
-    const handlers = new Map();
-    const mockServer = {
-        registerTool: (name, _config, handler) => {
-            handlers.set(name, handler);
-        },
-    };
-    registerTalentTools(mockServer, deps);
-    registerMessagingTools(mockServer, deps);
-    return handlers;
-}
-function extractToolResponseData(response) {
-    const structuredData = response.structuredContent?.data;
-    if (structuredData !== undefined) {
-        return structuredData;
-    }
-    const textContent = response.content[0]?.text;
-    if (typeof textContent !== "string" || textContent.length === 0) {
-        return null;
+async function whoamiCommand(args) {
+    const config = loadConfig();
+    if (!config) {
+        console.error("Not initialized. Run 'artemys start'.");
+        process.exitCode = 1;
+        return;
     }
+    const agentCard = await resolveAndReadAgentCard(args.flags);
+    const { coffeeShopClient, hasCoffeeShopApiKey } = buildNetworkDeps(args, agentCard);
+    let hubStatus = "unknown";
     try {
-        return JSON.parse(textContent);
+        const remote = await coffeeShopClient.getCard(agentCard.agent_id);
+        hubStatus = remote ? "connected" : "not found";
     }
     catch {
-        return textContent;
+        hubStatus = "unreachable";
     }
+    const cardPath = resolveAgentCardPath(args.flags);
+    const configPath = getConfigPath();
+    console.log(`
+Agent Identity
+  Handle:          ${agentCard.agent_id}
+  Display name:    ${agentCard.display_name}
+  Role:            ${agentCard.role}
+  Coffee Shop:     ${hubStatus}
+  API key:         ${hasCoffeeShopApiKey ? "configured" : "not set"}
+  Agent card:      ${cardPath ?? "not found"}
+  Config:          ${configPath}
+`);
 }
-async function invokeTalentTool(handlers, toolName, args) {
-    const handler = handlers.get(toolName);
-    if (!handler) {
-        throw new Error(`Talent tool '${toolName}' is unavailable`);
+async function doctorCommand(args) {
+    const checks = [];
+    // 1. Node.js version
+    const major = Number.parseInt(process.version.slice(1).split(".")[0], 10);
+    checks.push({
+        label: "Node.js >= 22",
+        ok: major >= 22,
+        detail: process.version,
+    });
+    // 2. Config exists
+    const config = loadConfig();
+    checks.push({
+        label: "Config exists",
+        ok: config !== null,
+        detail: config ? getConfigPath() : "Run 'artemys start'",
+    });
+    // 3. Agent card
+    let agentCard = null;
+    try {
+        agentCard = await resolveAndReadAgentCard(args.flags);
+        checks.push({ label: "Agent card valid", ok: true });
+    }
+    catch (err) {
+        checks.push({
+            label: "Agent card valid",
+            ok: false,
+            detail: err instanceof Error ? err.message : "Failed to read",
+        });
+    }
+    // 4 & 5. Coffee Shop reachable + API key valid (run in parallel)
+    if (config) {
+        const coffeeShopUrl = resolveCoffeeShopUrl(args.flags, config);
+        const healthCheck = fetch(`${coffeeShopUrl}/health`, {
+            signal: AbortSignal.timeout(5_000),
+        })
+            .then((response) => ({ ok: response.ok, detail: coffeeShopUrl }))
+            .catch(() => ({ ok: false, detail: coffeeShopUrl }));
+        const apiKeyCheck = agentCard
+            ? buildNetworkDeps(args, agentCard)
+                .coffeeShopClient.getCard(agentCard.agent_id)
+                .then((remote) => ({ ok: remote !== null, detail: undefined }))
+                .catch(() => ({ ok: false, detail: "getCard failed" }))
+            : Promise.resolve({ ok: false, detail: "Skipped (no agent card)" });
+        const [healthResult, apiKeyResult] = await Promise.all([healthCheck, apiKeyCheck]);
+        checks.push({ label: "Coffee Shop reachable", ...healthResult });
+        checks.push({ label: "API key valid", ...apiKeyResult });
+    }
+    else {
+        checks.push({ label: "Coffee Shop reachable", ok: false, detail: "No config" });
+        checks.push({ label: "API key valid", ok: false, detail: "Skipped (no config or card)" });
+    }
+    for (const check of checks) {
+        const status = check.ok ? "[OK]" : "[FAIL]";
+        const detail = check.detail ? ` (${check.detail})` : "";
+        console.log(`  ${status}  ${check.label}${detail}`);
+    }
+    const allOk = checks.every((c) => c.ok);
+    if (!allOk) {
+        process.exitCode = 1;
     }
-    const response = await handler(args);
-    return extractToolResponseData(response);
 }
 async function registerCommand(args) {
-    const cardPath = getFlagString(args.flags, "agent-card");
-    if (!cardPath) {
-        throw new Error("Missing required --agent-card <path>");
-    }
-    const card = await readAgentCardFromPath(cardPath);
-    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const card = await resolveAndReadAgentCard(args.flags);
+    const coffeeShopUrl = resolveCoffeeShopUrl(args.flags, loadConfig());
     const client = new CoffeeShopClient({ baseUrl: coffeeShopUrl });
     const result = await client.register(card);
     console.log(JSON.stringify(result, null, 2));
@@ -256,21 +329,22 @@ async function discoverCommand(args) {
         ...(capabilities ? { capabilities_any: capabilities } : {}),
         ...(limitRaw ? { limit: Number.parseInt(limitRaw, 10) } : {}),
     });
-    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const coffeeShopUrl = resolveCoffeeShopUrl(args.flags, loadConfig());
     const client = new CoffeeShopClient({ baseUrl: coffeeShopUrl });
     const results = await client.discover(query);
     console.log(JSON.stringify(results, null, 2));
 }
 async function rotateKeyCommand(args) {
-    const agentId = getFlagString(args.flags, "agent-id");
+    const config = loadConfig();
+    const agentId = getFlagString(args.flags, "agent-id") ?? config?.agent_id;
     if (!agentId) {
-        throw new Error("Missing required --agent-id <agent-id>");
+        throw new Error("Missing required --agent-id <agent-id> (or run 'artemys start')");
     }
-    const apiKey = getFlagString(args.flags, "api-key");
+    const apiKey = getFlagString(args.flags, "api-key") ?? resolveApiKey(config);
     if (!apiKey) {
-        throw new Error("Missing required --api-key <api-key>");
+        throw new Error("Missing required --api-key <api-key> (or run 'artemys start')");
     }
-    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const coffeeShopUrl = resolveCoffeeShopUrl(args.flags, config);
     const client = new CoffeeShopClient({
         baseUrl: coffeeShopUrl,
         apiKey,
@@ -278,25 +352,30 @@ async function rotateKeyCommand(args) {
     });
     const result = await client.rotateApiKey();
     console.log(JSON.stringify(result, null, 2));
-    console.log("Save api_key now. It is only returned at rotation time.");
+    // Update config.json if it exists and agent_id matches
+    if (config && config.agent_id === agentId) {
+        saveConfig({ ...config, api_key: result.api_key });
+        console.log("Config updated with new API key.");
+    }
+    else {
+        console.log("Save api_key now. It is only returned at rotation time.");
+    }
 }
 async function mcpServerCommand(args) {
-    const cardPath = getFlagString(args.flags, "agent-card");
-    if (!cardPath) {
-        throw new Error("Missing required --agent-card <path>");
-    }
     const transport = getFlagString(args.flags, "transport") === "sse" ? "sse" : "stdio";
     const portRaw = getFlagString(args.flags, "port");
     const port = portRaw ? Number.parseInt(portRaw, 10) : 3100;
     const persist = getPersistOption(args.flags);
-    const agentCard = await readAgentCardFromPath(cardPath);
+    const agentCard = await resolveAndReadAgentCard(args.flags);
     const { coffeeShopClient } = buildNetworkDeps(args, agentCard);
+    const token = getFlagString(args.flags, "mcp-token") || process.env.ARTEMYS_MCP_TOKEN || undefined;
     const started = await startArtemysMcpServer({
         agentCard,
         coffeeShopClient,
         transport,
         port,
         ...(persist ? { persist } : {}),
+        ...(token ? { token } : {}),
     });
     if (transport === "sse") {
         console.error(`Artemys MCP server listening on http://127.0.0.1:${port}/mcp`);
@@ -314,25 +393,42 @@ async function talentCommand(args) {
         printTalentHelp();
         return;
     }
-    const cardPath = getFlagString(args.flags, "agent-card");
-    if (!cardPath) {
-        throw new Error("Missing required --agent-card <path>");
-    }
-    const agentCard = await readAgentCardFromPath(cardPath);
+    const agentCard = await resolveAndReadAgentCard(args.flags);
     const { coffeeShopClient } = buildNetworkDeps(args, agentCard);
     const state = buildTalentState(args.flags);
     try {
-        const handlers = buildTalentToolHandlers({
-            coffeeShopClient,
-            tracker: state.tracker,
-            profileStore: state.profileStore,
-            agentCard,
-        });
+        if (subcommand === "whoami") {
+            const profile = state.profileStore.getProfile();
+            console.log(JSON.stringify({
+                agent_id: agentCard.agent_id,
+                display_name: agentCard.display_name,
+                has_profile: profile !== null,
+                profile,
+            }, null, 2));
+            return;
+        }
         if (subcommand === "search") {
+            const skillsRaw = getFlagString(args.flags, "skills");
+            const location = getFlagString(args.flags, "location");
+            const remote = getFlagBoolean(args.flags, "remote");
+            const minCompRaw = getFlagString(args.flags, "min-compensation");
+            const maxCompRaw = getFlagString(args.flags, "max-compensation");
             const limitRaw = getFlagString(args.flags, "limit");
-            const data = await invokeTalentTool(handlers, "search_opportunities", {
-                ...(limitRaw ? { limit: Number.parseInt(limitRaw, 10) } : {}),
-            });
+            const filters = {};
+            if (skillsRaw)
+                filters.skills = skillsRaw.split(",").map((s) => s.trim());
+            if (location)
+                filters.location = location;
+            if (typeof remote === "boolean")
+                filters.remote = remote;
+            if (minCompRaw)
+                filters.min_compensation = Number(minCompRaw);
+            if (maxCompRaw)
+                filters.max_compensation = Number(maxCompRaw);
+            if (limitRaw)
+                filters.limit = Number(limitRaw);
+            const hasFilters = Object.keys(filters).length > 0;
+            const data = await searchOpportunities(coffeeShopClient, hasFilters ? filters : undefined);
             console.log(JSON.stringify(data, null, 2));
             return;
         }
@@ -342,21 +438,47 @@ async function talentCommand(args) {
                 throw new Error("Missing required --job-id <job-id>");
             }
             const matchReasoning = getFlagString(args.flags, "match-reasoning");
-            const data = await invokeTalentTool(handlers, "express_interest", {
-                job_id: jobId,
-                ...(matchReasoning ? { match_reasoning: matchReasoning } : {}),
-            });
+            const storedProfile = state.profileStore.getProfile();
+            const snapshot = CandidateSnapshotSchema.parse(storedProfile ?? { display_name: agentCard.display_name });
+            const data = await expressInterest(coffeeShopClient, jobId, snapshot, matchReasoning ?? undefined);
             console.log(JSON.stringify(data, null, 2));
             return;
         }
         if (subcommand === "status") {
             const unreadOnly = getFlagBoolean(args.flags, "unread-only");
-            const data = await invokeTalentTool(handlers, "check_inbox", {
-                ...(typeof unreadOnly === "boolean" ? { unread_only: unreadOnly } : {}),
+            const data = await checkInbox(coffeeShopClient, {
+                unreadOnly: typeof unreadOnly === "boolean" ? unreadOnly : false,
             });
             console.log(JSON.stringify(data, null, 2));
             return;
         }
+        if (subcommand === "respond") {
+            const messageId = getFlagString(args.flags, "message-id");
+            if (!messageId) {
+                throw new Error("Missing required --message-id <id>");
+            }
+            const contentRaw = getFlagString(args.flags, "content");
+            if (!contentRaw) {
+                throw new Error("Missing required --content <json-string>");
+            }
+            let content;
+            try {
+                content = JSON.parse(contentRaw);
+                if (!content || typeof content !== "object" || Array.isArray(content)) {
+                    throw new Error("--content must be a JSON object");
+                }
+            }
+            catch (err) {
+                if (err instanceof SyntaxError) {
+                    throw new Error("--content must be valid JSON");
+                }
+                throw err;
+            }
+            const messageType = getFlagString(args.flags, "message-type");
+            const data = await respondToMessage(coffeeShopClient, messageId, content, messageType ?? undefined);
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
         if (subcommand === "profile") {
             const profilePath = getFlagString(args.flags, "profile-file");
             if (!profilePath) {
@@ -368,13 +490,21 @@ async function talentCommand(args) {
                 throw new Error("Profile file must contain a JSON object");
             }
             const syncAgentCard = getFlagBoolean(args.flags, "sync-agent-card");
-            const data = await invokeTalentTool(handlers, "update_profile", {
-                ...parsedProfile,
-                ...(typeof syncAgentCard === "boolean" ? { sync_agent_card: syncAgentCard } : {}),
+            const snapshot = CandidateSnapshotSchema.parse(parsedProfile);
+            const data = await updateProfile(coffeeShopClient, snapshot, {
+                profileStore: state.profileStore,
+                agentCard,
+                syncAgentCard: typeof syncAgentCard === "boolean" ? syncAgentCard : false,
             });
             console.log(JSON.stringify(data, null, 2));
             return;
         }
+        if (subcommand === "applications") {
+            const status = getFlagString(args.flags, "status");
+            const data = await getMyApplications(coffeeShopClient, status ? { status } : undefined);
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
         throw new Error(`Unknown talent subcommand: ${subcommand}`);
     }
     finally {
@@ -398,6 +528,19 @@ export async function runCli(argv = process.argv.slice(2)) {
         await versionCommand();
         return;
     }
+    if (command === "start" || command === "init") {
+        const { initCommand } = await import("./init.js");
+        await initCommand(args);
+        return;
+    }
+    if (command === "whoami") {
+        await whoamiCommand(args);
+        return;
+    }
+    if (command === "doctor") {
+        await doctorCommand(args);
+        return;
+    }
     if (command === "register") {
         await registerCommand(args);
         return;
@@ -418,6 +561,67 @@ export async function runCli(argv = process.argv.slice(2)) {
         await talentCommand(args);
         return;
     }
+    if (command === "parse-resume") {
+        const filePath = args.positionals[1];
+        if (!filePath) {
+            throw new Error("Missing required <file> argument");
+        }
+        const provider = getFlagString(args.flags, "provider");
+        if (!provider) {
+            throw new Error("Missing required --provider <provider>");
+        }
+        const validProviders = ["anthropic", "openai", "google"];
+        if (!validProviders.includes(provider)) {
+            throw new Error(`Unsupported provider "${provider}". Use: ${validProviders.join(", ")}`);
+        }
+        const envVarMap = {
+            anthropic: "ANTHROPIC_API_KEY",
+            openai: "OPENAI_API_KEY",
+            google: "GOOGLE_AI_API_KEY",
+        };
+        const envVar = envVarMap[provider];
+        const apiKey = getFlagString(args.flags, "api-key")
+            || (envVar ? process.env[envVar] : undefined);
+        if (!apiKey) {
+            throw new Error(`Missing API key. Set ${envVar} or pass --api-key`);
+        }
+        const model = getFlagString(args.flags, "model");
+        let text;
+        if (filePath.toLowerCase().endsWith(".pdf")) {
+            const [buffer, { default: pdf }] = await Promise.all([
+                readFile(filePath),
+                import("pdf-parse"),
+            ]);
+            try {
+                text = (await pdf(buffer)).text;
+            }
+            catch (err) {
+                throw new Error(`Failed to parse PDF "${filePath}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            text = await readFile(filePath, "utf-8");
+        }
+        const { parseResume } = await import("../resume/index.js");
+        const result = await parseResume(text, {
+            provider: provider,
+            apiKey,
+            ...(model ? { model } : {}),
+        });
+        await outputJson(result, getFlagString(args.flags, "output"));
+        return;
+    }
+    if (command === "to-card") {
+        const filePath = args.positionals[1];
+        if (!filePath) {
+            throw new Error("Missing required <file> argument");
+        }
+        const raw = await readFile(filePath, "utf-8");
+        const { toCard, FullResumeSchema } = await import("../resume/index.js");
+        const resume = FullResumeSchema.parse(JSON.parse(raw));
+        await outputJson(toCard(resume), getFlagString(args.flags, "output"));
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {