@twentyoz/alexx-cli 0.3.0

package/dist/commands/rec.js

@@ -0,0 +1,278 @@
+// rec: 기록(rec) 조작 — ls/search/get/status/upload/watch/transcript/notes/summarize/chat/retry/
+// rm(휴지통 이동)/restore/empty-trash
+// 편의 alias(ls/get/upload/chat) 는 동일 add* 함수를 program 루트에도 등록.
+// 각 명령은 withClient 로 등록 — handler/clientFromCommand 보일러플레이트는 action.ts 가 흡수.
+import { withClient } from "../action.js";
+import { AppError, printJson, printText, printJsonLine } from "../output.js";
+import { prompt } from "../prompt.js";
+import { parseDataOption } from "../data.js";
+import { listAllRecs, recPath, recStatus, renderTranscriptText, requireResult, streamProgress, stripWaveform, } from "../recs.js";
+// 서버(web/front/be recs-query.service.ts)의 페이지 상한 — 초과하면 서버가 조용히 클램프하므로
+// stderr 로 경고해 "다 받았다"는 오인을 막는다. 값이 서버와 어긋나도 경고 문구만 부정확할 뿐
+// 동작엔 영향 없음(실제 클램프는 서버가 한다).
+const SERVER_MAX_LIMIT = 100;
+function warnIfLimitCapped(limit, hint = "") {
+    if (!limit)
+        return;
+    const n = parseInt(limit, 10);
+    if (!Number.isFinite(n) || n <= SERVER_MAX_LIMIT)
+        return;
+    const tail = hint ? ` ${hint}` : "";
+    process.stderr.write(`warning: --limit ${n} exceeds the server max of ${SERVER_MAX_LIMIT}; capped to ${SERVER_MAX_LIMIT}.${tail}\n`);
+}
+// ── add*: 각 서브명령을 주어진 parent 에 등록 (rec 그룹 + alias 공용) ──
+function addLs(parent) {
+    parent
+        .command("ls")
+        .description("List recordings (cursor pagination; --trash lists trashed ones)")
+        .option("--cursor <recId>", "start after this rec_id")
+        .option("--limit <n>", "page size")
+        .option("--tag <tagId>", "filter by tag")
+        .option("--trash", "list trashed recordings (collection=trash)")
+        .option("--all", "follow the cursor and collect everything")
+        .action(withClient(async (client, opts) => {
+        warnIfLimitCapped(opts.limit, opts.all
+            ? "Page size is capped; --all still fetches every record."
+            : "Pass --all to fetch every record.");
+        // 휴지통 목록은 collection=trash — 미지정(undefined)이면 서버 기본(활성 기록).
+        const collection = opts.trash ? "trash" : undefined;
+        if (!opts.all) {
+            printJson(await client.request("GET", "/recs", {
+                query: {
+                    cursor: opts.cursor,
+                    limit: opts.limit,
+                    tag: opts.tag,
+                    collection,
+                },
+            }));
+            return;
+        }
+        printJson(await listAllRecs(client, {
+            cursor: opts.cursor,
+            limit: opts.limit,
+            tag: opts.tag,
+            collection,
+        }));
+    }));
+}
+function addSearch(parent) {
+    parent
+        .command("search <query>")
+        .description("Full-text search recordings (GET /recs/search)")
+        .option("--limit <n>", "number of results")
+        .option("--tag <tagId>", "filter by tag")
+        .action(withClient(async (client, query, opts) => {
+        warnIfLimitCapped(opts.limit);
+        printJson(await client.request("GET", "/recs/search", {
+            query: { q: query, limit: opts.limit, tag: opts.tag },
+        }));
+    }));
+}
+function addGet(parent) {
+    parent
+        .command("get <id>")
+        .description("Recording detail (waveform omitted by default)")
+        .option("--waveform", "include result.waveform")
+        .action(withClient(async (client, id, opts) => {
+        const detail = await client.request("GET", recPath(id));
+        printJson(opts.waveform ? detail : stripWaveform(detail));
+    }));
+}
+function addStatus(parent) {
+    parent
+        .command("status <id>")
+        .description("Lightweight status/progress (for polling)")
+        .action(withClient(async (client, id, _opts) => {
+        printJson(recStatus(await client.request("GET", recPath(id))));
+    }));
+}
+function addUpload(parent) {
+    parent
+        .command("upload <file>")
+        .description("Upload audio (multipart)")
+        .option("--wait", "wait for completion, then print detail (progress on stderr)")
+        .option("--skip-summary", "skip AI summary")
+        .option("--template <id>", "summary template id")
+        .option("--timezone <tz>", "client timezone (default: system)")
+        .option("--force", "ignore tier limit")
+        .option("--context <text>", "background context (topic/attendees/proper nouns) fed to AI post-processing (max 2000 chars)")
+        .action(withClient(async (client, file, opts) => {
+        const tz = opts.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const up = await client.upload("/upload", file, {
+            summary_tmpl_id: opts.template,
+            timezone: tz,
+            skip_summary: opts.skipSummary ? "true" : undefined,
+            force_upload: opts.force ? "true" : undefined,
+            context: opts.context,
+        });
+        if (!opts.wait) {
+            printJson(up);
+            return;
+        }
+        await streamProgress(client, up.rec_id, (e) => {
+            if (e.event !== "ping")
+                process.stderr.write(JSON.stringify(e) + "\n");
+        });
+        const detail = await client.request("GET", recPath(up.rec_id));
+        printJson(stripWaveform(detail));
+    }));
+}
+function addWatch(parent) {
+    parent
+        .command("watch <id>")
+        .description("Stream progress over SSE (JSON lines; ends on complete/error)")
+        .action(withClient(async (client, id, _opts) => {
+        await streamProgress(client, id, (e) => {
+            if (e.event !== "ping")
+                printJsonLine(e);
+        });
+    }));
+}
+function addTranscript(parent) {
+    parent
+        .command("transcript <id>")
+        .description("Transcript result (utterances)")
+        .option("--text", "print as `speaker: utterance` text")
+        .action(withClient(async (client, id, opts) => {
+        const result = requireResult(await client.request("GET", recPath(id)));
+        if (opts.text) {
+            printText(renderTranscriptText(result));
+            return;
+        }
+        printJson({
+            duration: result.duration,
+            speakers: result.speakers,
+            utterances: result.utterances,
+        });
+    }));
+}
+function addNotes(parent) {
+    parent
+        .command("notes <id>")
+        .description("List notes (user + AI summaries)")
+        .option("--ai", "only AI-generated summaries (is_ai_gen)")
+        .action(withClient(async (client, id, opts) => {
+        const notes = await client.request("GET", recPath(id, "/notes"));
+        printJson(opts.ai ? notes.filter((n) => n.is_ai_gen) : notes);
+    }));
+}
+function addSummarize(parent) {
+    parent
+        .command("summarize <id>")
+        .description("Regenerate the AI summary (POST /recs/:id/regenerate-summary)")
+        .option("--language <lang>", "language (default ko)")
+        .option("--template <id>", "summary template id")
+        .option("--data <json>", "raw JSON body (@file ok)")
+        .action(withClient(async (client, id, opts) => {
+        const body = { ...(parseDataOption(opts.data) ?? {}) };
+        if (opts.language)
+            body.language = opts.language;
+        if (opts.template)
+            body.template_id = opts.template;
+        printJson(await client.request("POST", recPath(id, "/regenerate-summary"), { body }));
+    }));
+}
+function addChat(parent) {
+    parent
+        .command("chat <id> [message...]")
+        .description("Chat with Alexx AI (POST /recs/:id/chat)")
+        .option("--thread <id>", "existing thread id")
+        .option("--language <lang>", "language (default ko)")
+        .option("--data <json>", "raw JSON body (@file ok)")
+        .action(withClient(async (client, id, messageParts, opts) => {
+        const body = { ...(parseDataOption(opts.data) ?? {}) };
+        const message = messageParts.join(" ").trim();
+        if (message)
+            body.message = message;
+        if (opts.thread)
+            body.thread_id = opts.thread;
+        if (opts.language)
+            body.language = opts.language;
+        if (!body.message) {
+            throw new AppError("usage", "A message is required.", {
+                hint: 'e.g. alexx rec chat <id> "summarize the key points" or --data \'{"message":"..."}\'',
+                exitCode: 2,
+            });
+        }
+        printJson(await client.request("POST", recPath(id, "/chat"), { body }));
+    }));
+}
+function addRetry(parent) {
+    parent
+        .command("retry <id>")
+        .description("Retry from the failed step (POST /recs/:id/retry)")
+        .action(withClient(async (client, id, _opts) => {
+        printJson(await client.request("POST", recPath(id, "/retry"), {}));
+    }));
+}
+/** 파괴적(복구 불가) 동작 앞의 확인 게이트 — 비-TTY 는 --yes 필수, TTY 는 y/N 프롬프트. */
+async function confirmDestructive(yes, question, usageHint) {
+    if (yes)
+        return;
+    if (!process.stdin.isTTY) {
+        throw new AppError("usage", "--yes is required to delete.", {
+            hint: usageHint,
+            exitCode: 2,
+        });
+    }
+    const ans = await prompt(question);
+    if (!ans || !/^y(es)?$/i.test(ans)) {
+        throw new AppError("aborted", "Aborted.", { exitCode: 1 });
+    }
+}
+function addRm(parent) {
+    parent
+        .command("rm <id>")
+        .description("Move a recording to trash (restorable for 30 days; use --permanent to delete now)")
+        .option("--permanent", "delete immediately instead of trashing (irreversible)")
+        .option("--yes", "delete without confirmation (--permanent only)")
+        .action(withClient(async (client, id, opts) => {
+        // 기본(휴지통 이동)은 복구 가능하므로 확인 없이 진행. 확인 게이트는 --permanent 만.
+        if (!opts.permanent) {
+            printJson(await client.request("DELETE", recPath(id)));
+            return;
+        }
+        await confirmDestructive(opts.yes, `Permanently delete ${id}? This cannot be undone. [y/N]: `, "In non-interactive mode use `alexx rec rm <id> --permanent --yes`.");
+        printJson(await client.request("DELETE", recPath(id, "/permanent")));
+    }));
+}
+function addRestore(parent) {
+    parent
+        .command("restore <id>")
+        .description("Restore a trashed recording (POST /recs/:id/restore)")
+        .action(withClient(async (client, id, _opts) => {
+        printJson(await client.request("POST", recPath(id, "/restore"), {}));
+    }));
+}
+function addEmptyTrash(parent) {
+    parent
+        .command("empty-trash")
+        .description("Permanently delete every trashed recording (irreversible)")
+        .option("--yes", "delete without confirmation")
+        .action(withClient(async (client, opts) => {
+        await confirmDestructive(opts.yes, "Permanently delete everything in trash? [y/N]: ", "In non-interactive mode use `alexx rec empty-trash --yes`.");
+        printJson(await client.request("DELETE", "/recs/trash"));
+    }));
+}
+export function registerRec(program) {
+    const rec = program.command("rec").description("Work with recordings");
+    addLs(rec);
+    addSearch(rec);
+    addGet(rec);
+    addStatus(rec);
+    addUpload(rec);
+    addWatch(rec);
+    addTranscript(rec);
+    addNotes(rec);
+    addSummarize(rec);
+    addChat(rec);
+    addRetry(rec);
+    addRm(rec);
+    addRestore(rec);
+    addEmptyTrash(rec);
+    // 편의 alias (top-level): 자주 쓰는 명령을 rec 없이 호출.
+    addLs(program);
+    addGet(program);
+    addUpload(program);
+    addChat(program);
+}

package/dist/config.js

@@ -0,0 +1,48 @@
+// 설정/토큰 저장. ${XDG_CONFIG_HOME:-~/.config}/alexx/config.json, 권한 0600.
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, rmSync, } from "node:fs";
+import { API_BASE_URL } from "./generated/endpoint.js";
+function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    return xdg ? join(xdg, "alexx") : join(homedir(), ".config", "alexx");
+}
+function configPath() {
+    return join(configDir(), "config.json");
+}
+export function loadConfig() {
+    try {
+        return JSON.parse(readFileSync(configPath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(cfg) {
+    const dir = configDir();
+    mkdirSync(dir, { recursive: true });
+    const p = configPath();
+    writeFileSync(p, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o600 });
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+export function clearConfig() {
+    try {
+        rmSync(configPath());
+    }
+    catch {
+        /* already gone */
+    }
+}
+/**
+ * base URL — 빌드 시 baked 된 고정값 (scripts/gen-endpoint.mjs).
+ * 런타임/CLI 플래그/환경변수로 변경 불가 — AI 가 임의로 dev/prod 를 건드리지 못하게 하는 가드레일.
+ * 환경 변경은 빌드 시점에만: `make build-cli env=local|dev|prod`.
+ */
+export function resolveBaseUrl() {
+    return API_BASE_URL;
+}

package/dist/data.js

@@ -0,0 +1,34 @@
+// --data <json|@file> 파서: 인자 파싱 우회용 raw JSON 바디 입력.
+import { readFileSync } from "node:fs";
+import { AppError } from "./output.js";
+export function parseDataOption(data) {
+    if (data === undefined)
+        return undefined;
+    let raw = data;
+    if (raw.startsWith("@")) {
+        // @- 는 stdin(fd 0) — "/dev/stdin" 경로는 Windows 에서 동작하지 않으므로 fd 를 직접 읽는다.
+        const src = raw === "@-" ? 0 : raw.slice(1);
+        try {
+            raw = readFileSync(src, "utf8");
+        }
+        catch (e) {
+            throw new AppError("usage", `Could not read --data file: ${raw === "@-" ? "stdin" : raw.slice(1)}`, {
+                hint: String(e instanceof Error ? e.message : e),
+                exitCode: 2,
+            });
+        }
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("must be a JSON object");
+        }
+        return parsed;
+    }
+    catch (e) {
+        throw new AppError("usage", `Failed to parse --data JSON: ${e instanceof Error ? e.message : e}`, {
+            hint: `e.g. --data '{"language":"en"}' or --data @body.json`,
+            exitCode: 2,
+        });
+    }
+}

package/dist/errors.js

@@ -0,0 +1,31 @@
+// HTTP 상태코드 → 구조화 에러(AppError) 매핑. 코드/힌트/exit code 규약의 단일 정본.
+import { AppError } from "./output.js";
+const HTTP_ERRORS = {
+    401: {
+        code: "unauthorized",
+        hint: "Sign in with `alexx auth login`, or set the ALEXX_TOKEN environment variable.",
+        exitCode: 3,
+        fallbackMessage: "Authentication required",
+    },
+    403: {
+        code: "forbidden",
+        hint: "Check your permissions or tier limit (`alexx api GET /tier/usage`).",
+    },
+    404: {
+        code: "not_found",
+        hint: "Check for a valid id with `alexx rec ls`.",
+    },
+    409: {
+        code: "conflict",
+        hint: "It may already be processing. Check with `alexx rec status <id>`.",
+    },
+};
+export function httpError(status, message) {
+    const spec = HTTP_ERRORS[status];
+    if (!spec)
+        return new AppError(`http_${status}`, message);
+    return new AppError(spec.code, message || spec.fallbackMessage || message, {
+        hint: spec.hint,
+        exitCode: spec.exitCode,
+    });
+}

package/dist/generated/endpoint.js

@@ -0,0 +1,3 @@
+// AUTO-GENERATED by scripts/gen-endpoint.mjs — do not edit. (build-time baked endpoint)
+export const API_BASE_URL = "https://alexx.app/api";
+export const BUILD_ENV = "prod";

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// Alexx CLI (alexx) — AI 에이전트를 위한 음성 분석 앱 조작 도구.
+// 기본 출력: 머신리더블 JSON. 에러: {"error":{code,message,hint}} → stderr.
+import { Command } from "commander";
+import { registerAuth } from "./commands/auth.js";
+import { registerRec } from "./commands/rec.js";
+import { registerMeta } from "./commands/meta.js";
+import { registerApi } from "./commands/api.js";
+import { setPretty, fail } from "./output.js";
+import { API_BASE_URL, BUILD_ENV } from "./generated/endpoint.js";
+import { VERSION } from "./version.js";
+const program = new Command();
+program
+    .name("alexx")
+    .description("Alexx CLI — drive the voice-analysis app (Front API). Output is JSON; errors are structured JSON on stderr.\n" +
+    "Auth: `alexx auth login` or ALEXX_TOKEN env. Search→Fetch→Act: `rec ls`/`rec search` → `rec get`/`rec transcript` → `rec chat`/`rec summarize`.\n" +
+    `endpoint: ${API_BASE_URL} (env=${BUILD_ENV}, baked at build time — not changeable at runtime)`)
+    .version(VERSION)
+    .option("--token <jwt>", "access token to use (env ALEXX_TOKEN)")
+    .option("--pretty", "pretty-print JSON output")
+    .enablePositionalOptions();
+program.hook("preAction", (_thisCommand, actionCommand) => {
+    const g = actionCommand.optsWithGlobals();
+    setPretty(!!g.pretty);
+});
+registerAuth(program);
+registerRec(program);
+registerMeta(program);
+registerApi(program);
+program.parseAsync(process.argv).catch((e) => fail(e));

package/dist/output.js

@@ -0,0 +1,59 @@
+// 출력 + 에러 규약. AI 친화: 기본 JSON, 에러는 What+Why+Hint 구조로 stderr, 안정적 exit code.
+/** exit code 규약: 0 성공 / 1 일반 / 2 사용법 / 3 인증 / 4 not found */
+export class AppError extends Error {
+    code;
+    hint;
+    exitCode;
+    constructor(code, message, opts = {}) {
+        super(message);
+        this.code = code;
+        this.hint = opts.hint;
+        this.exitCode = opts.exitCode ?? 1;
+    }
+}
+let pretty = false;
+export function setPretty(v) {
+    pretty = v;
+}
+export function printJson(data) {
+    // 빈 body(204/empty 200) 응답은 undefined → JSON.stringify 가 "undefined"(비-JSON) 를
+    // 내보내 stdout 파싱이 깨진다. null 로 보정해 항상 유효한 JSON 출력.
+    const safe = data === undefined ? null : data;
+    process.stdout.write(JSON.stringify(safe, null, pretty ? 2 : 0) + "\n");
+}
+export function printText(s) {
+    process.stdout.write(s.endsWith("\n") ? s : s + "\n");
+}
+/** 한 줄 JSON 스트림(watch SSE 용) — pretty 무관하게 항상 단일 라인. */
+export function printJsonLine(data) {
+    process.stdout.write(JSON.stringify(data) + "\n");
+}
+export function fail(err) {
+    let payload;
+    let exitCode = 1;
+    if (err instanceof AppError) {
+        payload = { code: err.code, message: err.message };
+        if (err.hint)
+            payload.hint = err.hint;
+        exitCode = err.exitCode;
+    }
+    else if (err instanceof Error) {
+        payload = { code: "error", message: err.message };
+    }
+    else {
+        payload = { code: "error", message: String(err) };
+    }
+    process.stderr.write(JSON.stringify({ error: payload }) + "\n");
+    process.exit(exitCode);
+}
+/** commander action 래퍼 — 예외를 구조화 에러로 변환하고 종료. */
+export function handler(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (e) {
+            fail(e);
+        }
+    };
+}

package/dist/prompt.js

@@ -0,0 +1,27 @@
+// TTY 대화형 입력 폴백 (비대화형이 기본 — env/flag 우선). 비-TTY 면 undefined.
+import { createInterface } from "node:readline";
+export async function prompt(label, mask = false) {
+    if (!process.stdin.isTTY)
+        return undefined;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // 비밀번호 마스킹: 출력 write 를 가로채 '*' 만 표시.
+    if (mask) {
+        const out = process.stdout;
+        const orig = out.write.bind(out);
+        rl._writeToOutput = (s) => {
+            if (s.includes(label))
+                orig(s);
+            else
+                orig("*".repeat(Math.max(0, s.replace(/\r?\n/g, "").length)));
+        };
+    }
+    try {
+        const answer = await new Promise((resolve) => rl.question(label, resolve));
+        if (mask)
+            process.stdout.write("\n");
+        return answer.trim() || undefined;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/recs.js

@@ -0,0 +1,92 @@
+// 기록(rec) 조회·가공 공용 로직 — 출력(stdout)은 commands/rec.ts 가 정하고 여기서는 값만 만든다.
+import { AppError } from "./output.js";
+/**
+ * `/recs/<id><suffix>` 경로. id 는 외부 입력이라 인코딩한다 — URL 파서가 `..` 를 정규화해
+ * `rec rm ../auth/account` 가 `DELETE /auth/account`(회원 탈퇴)로 새는 것을 막는다.
+ */
+export function recPath(id, suffix = "") {
+    return `/recs/${encodeURIComponent(id)}${suffix}`;
+}
+export function stripWaveform(detail) {
+    if (detail.result && "waveform" in detail.result) {
+        delete detail.result.waveform;
+    }
+    return detail;
+}
+/** SSE 진행 이벤트를 정규화해 콜백으로 전달. complete/error 에서 종료. */
+export async function streamProgress(client, id, onEvent) {
+    await client.sse(recPath(id, "/stream"), (ev) => {
+        let data;
+        try {
+            data = JSON.parse(ev.data);
+        }
+        catch {
+            data = ev.data;
+        }
+        const payload = data && typeof data === "object" ? data : { data };
+        onEvent({ event: ev.type, ...payload });
+        return ev.type === "complete" || ev.type === "error";
+    });
+}
+/** cursor 를 따라가며 전체 목록 수집 (rec_id 중복 제거). */
+export async function listAllRecs(client, query) {
+    const acc = [];
+    const seen = new Set();
+    let cursor = query.cursor;
+    for (;;) {
+        const page = await client.request("GET", "/recs", {
+            query: { ...query, cursor },
+        });
+        if (!page.length)
+            break;
+        let added = 0;
+        for (const r of page) {
+            if (!seen.has(r.rec_id)) {
+                seen.add(r.rec_id);
+                acc.push(r);
+                added += 1;
+            }
+        }
+        // 새로 추가된 게 없으면(전부 중복) 더 진행해도 의미 없음 → 종료. cursor 정체와
+        // 함께 무한루프/부분누락을 방지.
+        if (added === 0)
+            break;
+        const next = page[page.length - 1].rec_id;
+        if (next === cursor)
+            break;
+        cursor = next;
+    }
+    return acc;
+}
+/** 폴링용 경량 상태 투영. */
+export function recStatus(d) {
+    return {
+        rec_id: d.rec_id,
+        filename: d.filename,
+        status: d.status,
+        progress: d.progress,
+        error: d.error,
+        completed_at: d.completed_at,
+        has_result: d.has_result ?? !!d.result,
+    };
+}
+/** 전사 결과. 아직 완료 전이면 not_ready. */
+export function requireResult(d) {
+    if (d.status !== "completed" || !d.result) {
+        throw new AppError("not_ready", `No transcript available (status=${d.status}).`, {
+            hint: "Check progress with `alexx rec status <id>`.",
+        });
+    }
+    return d.result;
+}
+/** `화자: 발화` 텍스트. */
+export function renderTranscriptText(result) {
+    const speakers = result.speakers ?? {};
+    return result.utterances
+        .map((u) => {
+        const key = u.cluster ?? u.speaker;
+        const name = speakers[key]?.name ?? speakers[u.speaker]?.name ?? u.speaker;
+        return `${name}: ${u.text}`;
+    })
+        .join("\n");
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// API 응답 미러링 (web/front/fe/src/types/index.ts 기준 — CLI-local 사본).
+export {};

package/dist/version.js

@@ -0,0 +1,3 @@
+// 패키지 버전 단일 출처 — package.json 은 npm 발행본에도 항상 포함된다 (src/ 와 dist/ 모두 ../package.json).
+import { createRequire } from "node:module";
+export const VERSION = createRequire(import.meta.url)("../package.json").version;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@twentyoz/alexx-cli",
+  "version": "0.3.0",
+  "description": "Alexx CLI (alexx) — AI 에이전트를 위한 음성 분석 앱 조작 도구. npm 발행본은 운영 endpoint baked.",
+  "type": "module",
+  "bin": {
+    "alexx": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "gen": "node scripts/gen-endpoint.mjs",
+    "build": "npm run gen && tsc -p tsconfig.json",
+    "dev": "npm run gen && tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "tsx --test test/*.test.ts",
+    "prepare": "npm run build",
+    "prepublishOnly": "node scripts/assert-prod.mjs"
+  },
+  "dependencies": {
+    "commander": "15.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "tsx": "4.23.1",
+    "typescript": "5.9.3"
+  }
+}