@haenah/u1z 0.1.0

package/src/ai/llm/tools/textEditor.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { executeTextEditor } from "./textEditor";
+
+const TMP = `/tmp/u1z-text-editor-test-${Date.now()}.txt`;
+
+beforeEach(async () => {
+  const f = Bun.file(TMP);
+  if (await f.exists()) await unlink(TMP);
+});
+
+afterEach(async () => {
+  const f = Bun.file(TMP);
+  if (await f.exists()) await unlink(TMP);
+});
+
+describe("textEditor tool", () => {
+  test("create: creates file with given content", async () => {
+    const result = await executeTextEditor({
+      command: "create",
+      path: TMP,
+      file_text: "hello world",
+    });
+    expect(result).toMatchObject({ success: true });
+    expect(await Bun.file(TMP).text()).toBe("hello world");
+  });
+
+  test("view: returns full file content", async () => {
+    await Bun.write(TMP, "line1\nline2\nline3");
+    const result = await executeTextEditor({ command: "view", path: TMP });
+    expect(result).toMatchObject({ content: "line1\nline2\nline3" });
+  });
+
+  test("view: returns sliced content with view_range", async () => {
+    await Bun.write(TMP, "line1\nline2\nline3\nline4");
+    const result = await executeTextEditor({
+      command: "view",
+      path: TMP,
+      view_range: { start: 2, end: 3 },
+    });
+    expect(result).toMatchObject({ content: "line2\nline3" });
+  });
+
+  test("view: returns error for missing file", async () => {
+    const result = await executeTextEditor({ command: "view", path: "/tmp/nonexistent-u1z.txt" });
+    expect(result).toMatchObject({ error: expect.stringContaining("not found") });
+  });
+
+  test("str_replace: replaces matching string", async () => {
+    await Bun.write(TMP, "hello world");
+    const result = await executeTextEditor({
+      command: "str_replace",
+      path: TMP,
+      old_str: "world",
+      new_str: "universe",
+    });
+    expect(result).toMatchObject({ success: true });
+    expect(await Bun.file(TMP).text()).toBe("hello universe");
+  });
+
+  test("str_replace: returns error when old_str not found", async () => {
+    await Bun.write(TMP, "hello world");
+    const result = await executeTextEditor({
+      command: "str_replace",
+      path: TMP,
+      old_str: "notexist",
+      new_str: "x",
+    });
+    expect(result).toMatchObject({ error: expect.stringContaining("not found") });
+  });
+
+  test("insert: inserts line after given line number", async () => {
+    await Bun.write(TMP, "line1\nline2\nline3");
+    const result = await executeTextEditor({
+      command: "insert",
+      path: TMP,
+      insert_line: 1,
+      new_str: "inserted",
+    });
+    expect(result).toMatchObject({ success: true });
+    const content = await Bun.file(TMP).text();
+    expect(content).toBe("line1\ninserted\nline2\nline3");
+  });
+
+  test("insert: prepends when insert_line is 0", async () => {
+    await Bun.write(TMP, "line1\nline2");
+    await executeTextEditor({ command: "insert", path: TMP, insert_line: 0, new_str: "prepended" });
+    const content = await Bun.file(TMP).text();
+    expect(content).toBe("prepended\nline1\nline2");
+  });
+});

package/src/ai/llm/tools/textEditor.ts

@@ -0,0 +1,87 @@
+import { tool } from "ai";
+import { z } from "zod";
+
+type TextEditorInput = {
+  command: "view" | "str_replace" | "create" | "insert";
+  path: string;
+  view_range?: { start: number; end: number };
+  old_str?: string;
+  new_str?: string;
+  file_text?: string;
+  insert_line?: number;
+};
+
+export async function executeTextEditor({
+  command,
+  path,
+  view_range,
+  old_str,
+  new_str,
+  file_text,
+  insert_line,
+}: TextEditorInput) {
+  switch (command) {
+    case "view": {
+      const file = Bun.file(path);
+      if (!(await file.exists())) return { error: `File not found: ${path}` };
+      const text = await file.text();
+      if (!view_range) return { content: text };
+      const lines = text.split("\n");
+      const { start, end } = view_range;
+      const sliced = lines.slice(start - 1, end).join("\n");
+      return { content: sliced };
+    }
+
+    case "create": {
+      await Bun.write(path, file_text ?? "");
+      return { success: true };
+    }
+
+    case "str_replace": {
+      if (old_str === undefined || new_str === undefined)
+        return { error: "str_replace requires old_str and new_str" };
+      const file = Bun.file(path);
+      if (!(await file.exists())) return { error: `File not found: ${path}` };
+      const text = await file.text();
+      if (!text.includes(old_str)) return { error: `old_str not found in ${path}` };
+      await Bun.write(path, text.replace(old_str, new_str));
+      return { success: true };
+    }
+
+    case "insert": {
+      if (new_str === undefined || insert_line === undefined)
+        return { error: "insert requires new_str and insert_line" };
+      const file = Bun.file(path);
+      if (!(await file.exists())) return { error: `File not found: ${path}` };
+      const text = await file.text();
+      const lines = text.split("\n");
+      lines.splice(insert_line, 0, new_str);
+      await Bun.write(path, lines.join("\n"));
+      return { success: true };
+    }
+  }
+}
+
+export const textEditor = tool({
+  description:
+    "View or edit a file. Supports view (read), str_replace (find & replace), create (new file), and insert (add lines at a position).",
+  inputSchema: z.object({
+    command: z.enum(["view", "str_replace", "create", "insert"]),
+    path: z.string().describe("Absolute file path"),
+    view_range: z
+      .object({
+        start: z.number().describe("Start line (1-based, inclusive)"),
+        end: z.number().describe("End line (1-based, inclusive)"),
+      })
+      .optional()
+      .describe("Line range for view. Omit to view entire file."),
+    old_str: z.string().optional().describe("Exact string to replace (for str_replace)"),
+    new_str: z.string().optional().describe("Replacement string (for str_replace or insert)"),
+    file_text: z.string().optional().describe("Full file content to write (for create)"),
+    insert_line: z
+      .number()
+      .optional()
+      .describe("Line number after which to insert new_str (for insert, 0 = prepend)"),
+  }),
+  execute: executeTextEditor,
+});

package/src/ai/llm/tools/webFetch.ts

@@ -0,0 +1,41 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { tavilyClient as client } from "./tavilyClient";
+
+export const webFetch = tool({
+  description:
+    "Fetch and extract the full content of specific URLs. Use this when you need to read the actual content of a webpage. " +
+    "**For YouTube URLs, use `analyze_youtube` instead.** `web_fetch` cannot extract YouTube video content — it only retrieves the page HTML. `analyze_youtube` extracts subtitles and metadata for proper analysis.",
+  inputSchema: z.object({
+    urls: z.array(z.string()).max(20).describe("URLs to extract content from (max 20)"),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional intent hint to re-rank content chunks by relevance"),
+    format: z
+      .enum(["markdown", "text"])
+      .default("markdown")
+      .describe("Output format for extracted content"),
+    extract_depth: z
+      .enum(["basic", "advanced"])
+      .default("basic")
+      .describe(
+        "basic: fast extraction / advanced: handles JS-rendered pages, more complete content",
+      ),
+  }),
+  execute: async ({ urls, query, format, extract_depth }) => {
+    try {
+      const response = await client.extract(urls, { query, extractDepth: extract_depth, format });
+      return {
+        results: response.results.map((r) => ({ url: r.url, content: r.rawContent })),
+        failed: response.failedResults.map((r) => ({ url: r.url, error: r.error })),
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (msg.includes("401") || msg.toLowerCase().includes("unauthorized")) {
+        throw new Error("Tavily API key is invalid or expired");
+      }
+      throw e;
+    }
+  },
+});

package/src/ai/llm/tools/webSearch.ts

@@ -0,0 +1,84 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { tavilyClient as client } from "./tavilyClient";
+
+export const webSearch = tool({
+  description:
+    "Search the web and return relevant results. Use when the user asks about current events, real-time data, recent news, or facts that may have changed after your knowledge cutoff.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query"),
+    search_depth: z
+      .enum(["basic", "advanced"])
+      .default("basic")
+      .describe(
+        "Use 'basic' for most queries. Use 'advanced' when the question is technical or requires comprehensive coverage (e.g. researching a specific error, comparing products).",
+      ),
+    topic: z
+      .enum(["general", "news", "finance"])
+      .default("general")
+      .describe(
+        "Use 'news' when the user asks about recent events or breaking news. Use 'finance' for stock prices, earnings, or market data. Use 'general' otherwise.",
+      ),
+    max_results: z
+      .number()
+      .min(1)
+      .max(10)
+      .default(5)
+      .describe(
+        "Number of results to return (1–10). Use 3 for simple factual queries, 5 for general use, 10 when the user needs broad coverage.",
+      ),
+    include_answer: z
+      .enum(["false", "basic", "advanced"])
+      .default("false")
+      .describe(
+        "Include an AI-generated answer. Use 'basic' when a quick summary suffices. Use 'advanced' for complex questions where a detailed synthesized answer is more useful than raw results. Use 'false' when the user wants to see sources directly.",
+      ),
+    time_range: z
+      .enum(["day", "week", "month", "year"])
+      .optional()
+      .describe(
+        "Filter results by publish date. Use 'day' for breaking news or today's updates, 'week' for recent developments, 'month' for the latest trends. Omit when recency doesn't matter.",
+      ),
+    country: z
+      .enum(["south korea", "united states"])
+      .optional()
+      .describe(
+        "Boost results from a specific country. Use 'south korea' when the query is about Korean topics (domestic news, local services, Korean-language content). Use 'united states' for US-specific queries. Only applies when topic is 'general'.",
+      ),
+  }),
+  execute: async ({
+    query,
+    search_depth,
+    topic,
+    max_results,
+    include_answer,
+    time_range,
+    country,
+  }) => {
+    try {
+      const response = await client.search(query, {
+        searchDepth: search_depth,
+        topic,
+        maxResults: max_results,
+        includeAnswer: include_answer === "false" ? false : include_answer,
+        timeRange: time_range,
+        country,
+      });
+      return {
+        answer: response.answer,
+        results: response.results.map((r) => ({
+          title: r.title,
+          url: r.url,
+          content: r.content,
+          score: r.score,
+        })),
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (msg.includes("401") || msg.toLowerCase().includes("unauthorized")) {
+        throw new Error("Tavily API key is invalid or expired");
+      }
+      throw e;
+    }
+  },
+});

package/src/cli/commands/doctor.ts

@@ -0,0 +1,138 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { c } from "../utils/color";
+
+type CheckResult = { label: string; ok: boolean; hint?: string; optional?: boolean };
+
+async function spawnOutput(args: string[]): Promise<{ code: number; stdout: string }> {
+  try {
+    const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
+    const stdout = await new Response(proc.stdout).text();
+    return { code: await proc.exited, stdout: stdout.trim() };
+  } catch {
+    return { code: 127, stdout: "" };
+  }
+}
+
+async function checks(): Promise<CheckResult[]> {
+  const results: CheckResult[] = [];
+  const home = homedir();
+
+  // 1. bun
+  const bunPath = Bun.which("bun");
+  results.push({
+    label: "bun 설치",
+    ok: !!bunPath,
+    hint: bunPath ? undefined : "https://bun.sh/install",
+  });
+
+  // 2. yt-dlp
+  results.push({
+    label: "yt-dlp 설치",
+    ok: !!Bun.which("yt-dlp"),
+    hint: "sudo apt install -y yt-dlp",
+  });
+
+  // 3. ffmpeg
+  results.push({
+    label: "ffmpeg 설치",
+    ok: !!Bun.which("ffmpeg"),
+    hint: "sudo apt install -y ffmpeg",
+  });
+
+  // 4. gpg / pass (선택)
+  const gpgOk = !!Bun.which("gpg");
+  const passOk = !!Bun.which("pass");
+  results.push({
+    label: "gpg + pass 설치 (선택)",
+    ok: gpgOk && passOk,
+    hint: gpgOk && passOk ? undefined : "sudo apt install -y gnupg pass",
+    optional: true,
+  });
+
+  // 5. systemd user linger
+  const currentUser = process.env.USER ?? "";
+  const lingerFile = `/var/lib/systemd/linger/${currentUser}`;
+  results.push({
+    label: "systemd user linger 활성화",
+    ok: existsSync(lingerFile),
+    hint: `sudo loginctl enable-linger ${currentUser}`,
+  });
+
+  // 6. SSH authorized_keys
+  const sshKeyFile = join(home, ".ssh", "authorized_keys");
+  results.push({
+    label: "SSH authorized_keys 설정",
+    ok: existsSync(sshKeyFile),
+    hint: "~/.ssh/authorized_keys 파일이 없습니다",
+  });
+
+  // 7. U1Z_HOME 구조
+  const u1zHome = process.env.U1Z_HOME ?? "";
+  const u1zDir = join(u1zHome, ".u1z");
+  const promptDir = join(u1zDir, "prompt");
+  results.push({
+    label: "U1Z_HOME 디렉토리 구조",
+    ok: !!u1zHome && existsSync(promptDir),
+    hint: u1zHome ? `u1z init 실행 필요 (${promptDir} 없음)` : "U1Z_HOME 환경변수 미설정",
+  });
+
+  // 8. .env 필수 변수
+  const envPath = u1zHome ? join(u1zHome, ".env") : "";
+  const requiredVars = [
+    "DISCORD_BOT_TOKEN",
+    "OPENAI_API_KEY",
+    "GOOGLE_GENERATIVE_AI_API_KEY",
+    "TAVILY_API_KEY",
+  ];
+  const missingVars = requiredVars.filter((k) => !process.env[k]);
+  results.push({
+    label: ".env 필수 변수",
+    ok: missingVars.length === 0,
+    hint:
+      missingVars.length > 0
+        ? `누락: ${missingVars.join(", ")} — ${envPath || "U1Z_HOME/.env"}`
+        : undefined,
+  });
+
+  // 9. systemd u1z.service 등록 여부
+  const { code: statusCode } = await spawnOutput(["systemctl", "--user", "is-enabled", "u1z"]);
+  results.push({
+    label: "u1z.service systemd 등록",
+    ok: statusCode === 0,
+    hint: "u1z init 실행 필요",
+  });
+
+  // 10. u1z.service 현재 실행 중
+  const { code: activeCode } = await spawnOutput(["systemctl", "--user", "is-active", "u1z"]);
+  results.push({
+    label: "u1z.service 실행 중",
+    ok: activeCode === 0,
+    hint: "systemctl --user start u1z",
+  });
+
+  return results;
+}
+
+export async function doctor(): Promise<void> {
+  console.log(c.bold("\nu1z doctor\n"));
+
+  const results = await checks();
+  let allOk = true;
+
+  for (const { label, ok, hint, optional } of results) {
+    const icon = ok ? c.green("✓") : optional ? c.yellow("–") : c.red("✗");
+    console.log(`  ${icon}  ${label}`);
+    if (!ok && hint) console.log(`       ${c.dim(hint)}`);
+    if (!ok && !optional) allOk = false;
+  }
+
+  console.log();
+  if (allOk) {
+    console.log(c.green(c.bold("모든 항목 정상")));
+  } else {
+    console.log(c.yellow("일부 항목을 확인해주세요."));
+    process.exit(1);
+  }
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,130 @@
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { c } from "../utils/color";
+import { ask, confirm } from "../utils/prompt";
+
+async function run(args: string[]): Promise<void> {
+  const proc = Bun.spawn(args, { stdout: "inherit", stderr: "inherit" });
+  const code = await proc.exited;
+  if (code !== 0) throw new Error(`'${args.join(" ")}' 실패 (exit ${code})`);
+}
+
+async function step(label: string, fn: () => Promise<void>): Promise<void> {
+  console.log(`\n${c.bold(`▶ ${label}`)}`);
+  try {
+    await fn();
+    console.log(c.green("  완료"));
+  } catch (err) {
+    console.error(c.red(`  실패: ${err instanceof Error ? err.message : err}`));
+    process.exit(1);
+  }
+}
+
+function ensureDir(path: string): void {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+    console.log(c.dim(`  mkdir ${path}`));
+  }
+}
+
+export async function init(): Promise<void> {
+  console.log(c.bold("\nu1z init"));
+
+  // 1. U1Z_HOME 경로
+  const u1zHome = await ask("U1Z_HOME 경로", process.env.HOME ?? homedir());
+  if (!u1zHome) {
+    console.error(c.red("U1Z_HOME 경로가 필요합니다."));
+    process.exit(1);
+  }
+
+  // 2. 디렉토리 구조 생성
+  await step("디렉토리 구조 생성", async () => {
+    const u1zDir = join(u1zHome, ".u1z");
+    ensureDir(join(u1zDir, "prompt"));
+    ensureDir(join(u1zDir, "memory"));
+    ensureDir(join(u1zDir, "skills"));
+
+    // 프롬프트 템플릿 복사 (존재하면 스킵)
+    const bootstrapDir = join(import.meta.dir, "../../../u1z_home_bootstrap/.u1z");
+    for (const file of ["BASE.md", "MEMORIZE.md", "DREAM.md"]) {
+      const dest = join(u1zDir, "prompt", file);
+      if (!existsSync(dest)) {
+        copyFileSync(join(bootstrapDir, "prompt", file), dest);
+        console.log(c.dim(`  copied ${file}`));
+      } else {
+        console.log(c.dim(`  skip ${file} (already exists)`));
+      }
+    }
+  });
+
+  // 3. .env 설정
+  const envPath = join(u1zHome, ".env");
+  await step(".env 설정", async () => {
+    if (existsSync(envPath)) {
+      const overwrite = await confirm(".env 파일이 이미 존재합니다. 덮어쓸까요?", false);
+      if (!overwrite) {
+        console.log(c.dim("  기존 .env 유지"));
+        return;
+      }
+    }
+
+    const vars: Record<string, string> = {};
+    for (const key of [
+      "DISCORD_BOT_TOKEN",
+      "OPENAI_API_KEY",
+      "GOOGLE_GENERATIVE_AI_API_KEY",
+      "TAVILY_API_KEY",
+    ]) {
+      vars[key] = await ask(key);
+      if (!vars[key]) {
+        throw new Error(`${key}는 필수 항목입니다.`);
+      }
+    }
+    vars.U1Z_HOME = u1zHome;
+    vars.PORT = (await ask("PORT", "3000")) || "3000";
+
+    const content = Object.entries(vars)
+      .map(([k, v]) => `${k}="${v.replace(/"/g, '\\"')}"`)
+      .join("\n");
+    writeFileSync(envPath, `${content}\n`, "utf-8");
+    console.log(c.dim(`  wrote ${envPath}`));
+  });
+
+  // 4. systemd unit 파일 설정
+  await step("systemd user 서비스 설정", async () => {
+    const serviceDir = join(homedir(), ".config", "systemd", "user");
+    const servicePath = join(serviceDir, "u1z.service");
+
+    ensureDir(serviceDir);
+
+    const u1zBin = Bun.which("u1z") ?? join(homedir(), ".bun", "bin", "u1z");
+
+    const serviceContent = `[Unit]
+Description=u1z AI 집 비서
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${u1zHome}
+ExecStart=${u1zBin} server
+EnvironmentFile=${envPath}
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=default.target
+`;
+    writeFileSync(servicePath, serviceContent, "utf-8");
+    console.log(c.dim(`  wrote ${servicePath}`));
+
+    await run(["systemctl", "--user", "daemon-reload"]);
+    await run(["systemctl", "--user", "enable", "u1z"]);
+    await run(["systemctl", "--user", "restart", "u1z"]);
+    console.log(c.dim("  u1z.service enabled & restarted"));
+  });
+
+  console.log(`\n${c.green(c.bold("초기화 완료"))}`);
+  console.log(c.dim("  상태 확인: u1z status"));
+  console.log(c.dim("  로그 확인: u1z logs"));
+}

package/src/cli/commands/logs.ts

@@ -0,0 +1,11 @@
+export async function logs(argv: { n?: number }): Promise<void> {
+  const args = ["journalctl", "--user", "-u", "u1z"];
+  if (argv.n !== undefined) args.push("-n", String(argv.n));
+  args.push("-f");
+  const proc = Bun.spawn(args, {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  });
+  process.exit(await proc.exited);
+}

package/src/cli/commands/server.ts

@@ -0,0 +1,28 @@
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { startDiscord } from "@/discord";
+
+const REQUIRED_ENV_VARS = [
+  "DISCORD_BOT_TOKEN",
+  "OPENAI_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "TAVILY_API_KEY",
+  "U1Z_HOME",
+] as const;
+
+export async function server(): Promise<void> {
+  for (const key of REQUIRED_ENV_VARS) {
+    if (!process.env[key]) throw new Error(`Missing required env var: ${key}`);
+  }
+
+  const app = new Hono();
+  app.use(logger());
+  app.get("/health", (c) => c.json({ status: "ok", timestamp: new Date().toISOString() }));
+
+  await startDiscord();
+
+  const port = Number(process.env.PORT ?? 3000);
+  console.log(`[Server] Running on port ${port}`);
+
+  Bun.serve({ port, fetch: app.fetch });
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,8 @@
+export async function status(): Promise<void> {
+  const proc = Bun.spawn(["systemctl", "--user", "status", "u1z"], {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  });
+  process.exit(await proc.exited);
+}

package/src/cli/commands/update.ts

@@ -0,0 +1,21 @@
+import { confirm } from "../utils/prompt";
+
+async function run(args: string[]): Promise<number> {
+  const proc = Bun.spawn(args, { stdout: "inherit", stderr: "inherit" });
+  return proc.exited;
+}
+
+export async function update(): Promise<void> {
+  const code = await run(["bun", "add", "-g", "@haenah/u1z@latest"]);
+  if (code !== 0) process.exit(code);
+
+  console.log("업데이트 완료.");
+  const restart = await confirm("서비스를 지금 재시작할까요?", true);
+  if (restart) {
+    const restartCode = await run(["systemctl", "--user", "restart", "u1z"]);
+    if (restartCode !== 0) process.exit(restartCode);
+    console.log("서비스 재시작 완료.");
+  } else {
+    console.log("재시작하려면: systemctl --user restart u1z");
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+yargs(hideBin(process.argv))
+  .scriptName("u1z")
+  .command("init", "대화형 초기 셋업 및 systemd 서비스 등록", {}, () =>
+    import("./commands/init").then((m) => m.init()),
+  )
+  .command("doctor", "사전 조건 및 환경 상태 점검", {}, () =>
+    import("./commands/doctor").then((m) => m.doctor()),
+  )
+  .command("status", "서비스 상태 확인", {}, () =>
+    import("./commands/status").then((m) => m.status()),
+  )
+  .command(
+    "logs",
+    "서비스 로그 스트리밍",
+    { n: { type: "number", describe: "최근 N줄" } },
+    (argv) => import("./commands/logs").then((m) => m.logs(argv)),
+  )
+  .command("update", "최신 버전으로 업데이트", {}, () =>
+    import("./commands/update").then((m) => m.update()),
+  )
+  .command("server", false, {}, () => import("./commands/server").then((m) => m.server()))
+  .demandCommand(1)
+  .strict()
+  .help()
+  .parse();

package/src/cli/utils/color.ts

@@ -0,0 +1,7 @@
+export const c = {
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+};