@laddro/career-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Laddro Digital UG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @laddro/career-cli
+
+CLI for the [Laddro Career API](https://api.laddro.com/reference). Tailor resumes, generate cover letters, and export PDFs from your terminal.
+
+## Install
+
+```bash
+npm install -g @laddro/career-cli
+```
+
+## Quick start
+
+```bash
+# Save your API key
+laddro login laddro_live_...
+
+# List your resumes
+laddro resumes
+
+# Tailor a resume for a job
+laddro tailor "Senior Frontend Engineer" --job-url https://jobs.example.com/sfe
+
+# Generate a cover letter
+laddro cover-letter generate "Product Manager" --job-url https://jobs.example.com/pm
+
+# Export as PDF with a different template
+laddro export abc-123 --template COBALT --output my-resume.pdf
+
+# Parse and render an existing PDF
+laddro parse ./old-resume.pdf --template GRAPHITE
+
+# Browse templates
+laddro templates
+laddro templates GRAPHITE
+
+# Configure BYOK
+laddro settings set --provider Anthropic --model claude-sonnet-4-20250514 --key sk-ant-...
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `login <key>` | Save API key to `~/.laddro/config.json` |
+| `logout` | Remove saved API key |
+| `resumes` | List your resumes |
+| `tailor <position>` | Tailor resume for a job |
+| `export <id>` | Export resume as PDF |
+| `parse <file>` | Parse PDF and render with template |
+| `cover-letter list` | List cover letters |
+| `cover-letter generate <position>` | Generate cover letter |
+| `templates [id]` | Browse templates |
+| `settings` | View AI config |
+| `settings set` | Set BYOK provider |
+| `settings remove` | Remove AI config |
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `LADDRO_API_KEY` | API key (overrides config file) |
+| `LADDRO_BASE_URL` | Custom API URL |
+
+## Links
+
+- [Laddro](https://laddro.com) — AI-powered career tools
+- [API Reference](https://api.laddro.com/reference) — Interactive docs
+- [Documentation](https://docs.laddro.com) — Guides and tutorials
+- [GitHub](https://github.com/laddro-app) — All SDKs and tools
+
+## License
+
+MIT

package/dist/commands.d.ts

@@ -0,0 +1,10 @@
+export declare function login(args: string[]): Promise<void>;
+export declare function logout(): Promise<void>;
+export declare function resumes(args: string[]): Promise<void>;
+export declare function tailor(args: string[]): Promise<void>;
+export declare function exportResume(args: string[]): Promise<void>;
+export declare function coverLetter(args: string[]): Promise<void>;
+export declare function parse(args: string[]): Promise<void>;
+export declare function templates(args: string[]): Promise<void>;
+export declare function settings(args: string[]): Promise<void>;
+export declare function help(): void;

package/dist/commands.js

@@ -0,0 +1,241 @@
+import { readFileSync } from "fs";
+import { Laddro } from "@laddro/career-sdk";
+import { getApiKey, getBaseUrl, getConfig, saveConfig } from "./config.js";
+import { error, printJSON, printTable, savePDF } from "./output.js";
+function client() {
+    const apiKey = getApiKey();
+    if (!apiKey)
+        error("No API key. Run: laddro login <key>");
+    return new Laddro({ apiKey, baseUrl: getBaseUrl() });
+}
+function publicClient() {
+    return new Laddro({ baseUrl: getBaseUrl() });
+}
+export async function login(args) {
+    const key = args[0];
+    if (!key)
+        error("Usage: laddro login <api-key>");
+    const config = getConfig();
+    config.apiKey = key;
+    saveConfig(config);
+    console.log("API key saved to ~/.laddro/config.json");
+}
+export async function logout() {
+    const config = getConfig();
+    delete config.apiKey;
+    saveConfig(config);
+    console.log("API key removed.");
+}
+export async function resumes(args) {
+    const c = client();
+    const list = await c.resumes.list({ limit: 20 });
+    printTable(list.items.map((r) => ({
+        id: r.resumeId,
+        title: r.title,
+        default: r.isDefault ? "✓" : "",
+        updated: r.updatedAt.split("T")[0],
+    })), ["id", "title", "default", "updated"]);
+    if (list.total > list.items.length) {
+        console.log(`\n(showing ${list.items.length} of ${list.total})`);
+    }
+}
+export async function tailor(args) {
+    const c = client();
+    const flags = parseFlags(args);
+    const positionName = flags.positional[0];
+    if (!positionName)
+        error("Usage: laddro tailor <position> --job-url <url> [--output <file>]");
+    const outputFile = flags.get("output") || flags.get("o") || "tailored.pdf";
+    console.log(`Tailoring for: ${positionName}`);
+    const pdf = await c.tailor.run({
+        resumeId: flags.get("resume") || undefined,
+        positionName,
+        jobDescription: flags.get("job-description") || undefined,
+        jobUrl: flags.get("job-url") || flags.get("job") || undefined,
+        mode: flags.get("mode") || undefined,
+        language: flags.get("language") || undefined,
+        templateId: flags.get("template") || undefined,
+    });
+    savePDF(pdf, outputFile);
+}
+export async function exportResume(args) {
+    const c = client();
+    const flags = parseFlags(args);
+    const resumeId = flags.positional[0];
+    if (!resumeId)
+        error("Usage: laddro export <resume-id> [--template GRAPHITE] [--output <file>]");
+    const outputFile = flags.get("output") || flags.get("o") || "resume.pdf";
+    const pdf = await c.export.pdf({
+        resumeId,
+        templateId: flags.get("template") || undefined,
+        colorId: flags.get("color") || undefined,
+        font: flags.get("font") || undefined,
+        locale: flags.get("locale") || undefined,
+    });
+    savePDF(pdf, outputFile);
+}
+export async function coverLetter(args) {
+    const c = client();
+    const subcommand = args[0];
+    if (subcommand === "list" || !subcommand) {
+        const list = await c.coverLetters.list({ limit: 20 });
+        printTable(list.items.map((cl) => ({
+            id: cl.coverLetterId,
+            title: cl.title,
+            updated: cl.updatedAt.split("T")[0],
+        })), ["id", "title", "updated"]);
+        return;
+    }
+    if (subcommand === "generate") {
+        const flags = parseFlags(args.slice(1));
+        const positionName = flags.positional[0];
+        if (!positionName)
+            error("Usage: laddro cover-letter generate <position> --job-url <url>");
+        const outputFile = flags.get("output") || flags.get("o") || "cover-letter.pdf";
+        console.log(`Generating cover letter for: ${positionName}`);
+        const pdf = await c.coverLetters.generate({
+            resumeId: flags.get("resume") || undefined,
+            positionName,
+            jobDescription: flags.get("job-description") || undefined,
+            jobUrl: flags.get("job-url") || flags.get("job") || undefined,
+            language: flags.get("language") || undefined,
+            templateId: flags.get("template") || undefined,
+        });
+        savePDF(pdf, outputFile);
+        return;
+    }
+    error(`Unknown subcommand: cover-letter ${subcommand}. Use: list, generate`);
+}
+export async function parse(args) {
+    const c = client();
+    const flags = parseFlags(args);
+    const filePath = flags.positional[0];
+    if (!filePath)
+        error("Usage: laddro parse <file.pdf> [--template GRAPHITE] [--output <file>]");
+    const outputFile = flags.get("output") || flags.get("o") || "parsed.pdf";
+    const fileBuffer = readFileSync(filePath);
+    console.log(`Parsing: ${filePath}`);
+    const pdf = await c.resumes.parse({
+        file: fileBuffer,
+        filename: filePath.split("/").pop(),
+        templateId: flags.get("template") || undefined,
+        locale: flags.get("locale") || undefined,
+        colorId: flags.get("color") || undefined,
+        font: flags.get("font") || undefined,
+    });
+    savePDF(pdf, outputFile);
+}
+export async function templates(args) {
+    const c = publicClient();
+    const templateId = args[0];
+    if (templateId) {
+        const detail = await c.templates.get(templateId);
+        printJSON(detail);
+        return;
+    }
+    const list = await c.templates.list();
+    printTable(list.map((t) => ({
+        id: t.id,
+        name: t.name,
+        ats: t.atsScore,
+        layout: t.layoutType,
+    })), ["id", "name", "ats", "layout"]);
+}
+export async function settings(args) {
+    const c = client();
+    const subcommand = args[0];
+    if (subcommand === "set") {
+        const flags = parseFlags(args.slice(1));
+        const provider = flags.get("provider");
+        const apiKey = flags.get("key");
+        if (!provider || !apiKey)
+            error("Usage: laddro settings set --provider <name> --key <key> [--model <id>]");
+        const result = await c.settings.updateModel({
+            provider,
+            model: flags.get("model") || undefined,
+            apiKey,
+        });
+        console.log(`AI provider set: ${result.ai?.provider} / ${result.ai?.model}`);
+        return;
+    }
+    if (subcommand === "remove") {
+        await c.settings.deleteModel();
+        console.log("AI settings removed. Using Laddro defaults.");
+        return;
+    }
+    const result = await c.settings.get();
+    if (result.ai) {
+        printJSON(result.ai);
+    }
+    else {
+        console.log("No AI provider configured. Using Laddro defaults.");
+    }
+}
+export function help() {
+    console.log(`laddro — Laddro Career API CLI
+
+Commands:
+  login <api-key>           Save API key
+  logout                    Remove saved API key
+  resumes                   List your resumes
+  tailor <position>         Tailor resume for a job
+  export <resume-id>        Export resume as PDF
+  parse <file.pdf>          Parse and render a PDF resume
+  cover-letter list         List cover letters
+  cover-letter generate     Generate a cover letter
+  templates [id]            Browse templates
+  settings                  View AI settings
+  settings set              Configure BYOK provider
+  settings remove           Remove AI config
+  help                      Show this help
+
+Flags (vary by command):
+  --job-url, --job          Job posting URL
+  --job-description         Job description text
+  --resume                  Resume ID (uses default otherwise)
+  --template                Template ID (e.g. GRAPHITE)
+  --output, -o              Output file path
+  --language                Output language code
+  --mode                    Tailor mode (standard|new)
+  --provider                AI provider name
+  --model                   AI model ID
+  --key                     AI provider API key
+
+Environment:
+  LADDRO_API_KEY            API key (overrides config file)
+  LADDRO_BASE_URL           Custom API URL
+`);
+}
+function parseFlags(args) {
+    const positional = [];
+    const flags = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags.set(key, next);
+                i++;
+            }
+            else {
+                flags.set(key, "true");
+            }
+        }
+        else if (arg.startsWith("-") && arg.length === 2) {
+            const key = arg.slice(1);
+            const next = args[i + 1];
+            if (next && !next.startsWith("-")) {
+                flags.set(key, next);
+                i++;
+            }
+            else {
+                flags.set(key, "true");
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { positional, get: (key) => flags.get(key) };
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+interface Config {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function getConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function getApiKey(): string;
+export declare function getBaseUrl(): string;
+export {};

package/dist/config.js

@@ -0,0 +1,30 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const CONFIG_DIR = join(homedir(), ".laddro");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function getConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+export function getApiKey() {
+    const envKey = process.env.LADDRO_API_KEY;
+    if (envKey)
+        return envKey;
+    const config = getConfig();
+    return config.apiKey || "";
+}
+export function getBaseUrl() {
+    return process.env.LADDRO_BASE_URL || getConfig().baseUrl || "https://api.laddro.com";
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { LaddroAPIError } from "@laddro/career-sdk";
+import * as commands from "./commands.js";
+const [command, ...args] = process.argv.slice(2);
+async function run() {
+    switch (command) {
+        case "login":
+            return commands.login(args);
+        case "logout":
+            return commands.logout();
+        case "resumes":
+            return commands.resumes(args);
+        case "tailor":
+            return commands.tailor(args);
+        case "export":
+            return commands.exportResume(args);
+        case "parse":
+            return commands.parse(args);
+        case "cover-letter":
+            return commands.coverLetter(args);
+        case "templates":
+            return commands.templates(args);
+        case "settings":
+            return commands.settings(args);
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            return commands.help();
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error("Run 'laddro help' for usage.");
+            process.exit(1);
+    }
+}
+run().catch((err) => {
+    if (err instanceof LaddroAPIError) {
+        console.error(`error: ${err.message} (${err.status})`);
+    }
+    else {
+        console.error(`error: ${err.message || err}`);
+    }
+    process.exit(1);
+});

package/dist/output.d.ts

@@ -0,0 +1,6 @@
+export declare function printJSON(data: unknown): void;
+export declare function printTable(rows: Record<string, unknown>[], columns?: string[]): void;
+export declare function savePDF(data: ArrayBuffer | bytes, outputPath: string): void;
+export declare function error(message: string): never;
+type bytes = Uint8Array;
+export {};

package/dist/output.js

@@ -0,0 +1,28 @@
+import { writeFileSync } from "fs";
+export function printJSON(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function printTable(rows, columns) {
+    if (rows.length === 0) {
+        console.log("(no results)");
+        return;
+    }
+    const keys = columns || Object.keys(rows[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length)));
+    const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+    const sep = widths.map((w) => "-".repeat(w)).join("  ");
+    console.log(header);
+    console.log(sep);
+    for (const row of rows) {
+        const line = keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ");
+        console.log(line);
+    }
+}
+export function savePDF(data, outputPath) {
+    writeFileSync(outputPath, Buffer.from(data));
+    console.log(`Saved: ${outputPath}`);
+}
+export function error(message) {
+    console.error(`error: ${message}`);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@laddro/career-cli",
+  "version": "0.1.0",
+  "description": "CLI for the Laddro Career API — tailor resumes, generate cover letters, export PDFs from the terminal",
+  "type": "module",
+  "bin": {
+    "laddro": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "laddro",
+    "career",
+    "resume",
+    "cli",
+    "cover-letter"
+  ],
+  "author": "Laddro <support@laddro.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/laddro-app/laddro-career-cli"
+  },
+  "homepage": "https://docs.laddro.com",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@laddro/career-sdk": "file:../laddro-career-sdk-ts",
+    "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.18",
+    "typescript": "^5.9.3"
+  }
+}