@mathzdevolper/phantomcode-cli 1.0.0

package/src/commands/models.ts

@@ -0,0 +1,41 @@
+import { getApiKey } from "../config/manager";
+import { listModels } from "../provider/dogrouter";
+import { style } from "../tui/colors";
+
+interface ModelsArgs {
+  search?: string;
+}
+
+export async function handleModels(args: ModelsArgs): Promise<void> {
+  let apiKey: string;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    console.error(style.error("✗ API key nao configurada"));
+    console.log(style.muted("  Execute: phantomcode config set <sua-api-key>"));
+    process.exit(1);
+  }
+
+  try {
+    const models = await listModels(apiKey);
+
+    const filtered = args.search
+      ? models.filter((m) => m.id.toLowerCase().includes(args.search!.toLowerCase()))
+      : models;
+
+    if (filtered.length === 0) {
+      console.log(style.warning("Nenhum modelo encontrado"));
+      return;
+    }
+
+    console.log(style.header(`┌─ Modelos Disponiveis (${filtered.length}) ───────────`));
+    for (const m of filtered) {
+      console.log(`│ ${style.code(m.id)}`);
+    }
+    console.log(style.header("└───────────────────────────────────────────"));
+  } catch (error: unknown) {
+    const err = error as { message?: string };
+    console.error(style.error(`✗ Erro ao listar modelos: ${err.message || "Erro desconhecido"}`));
+    process.exit(1);
+  }
+}

package/src/commands/session.ts

@@ -0,0 +1,93 @@
+import { listSessions, getSession, deleteSession } from "../session/manager";
+import { style } from "../tui/colors";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function buildSessionCommand(yargs: any): any {
+  return yargs
+    .command(
+      "list",
+      "Lista todas as sessoes salvas",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (y: any) =>
+        y.option("limit", {
+          alias: "n",
+          describe: "Numero maximo de sessoes",
+          type: "number",
+          default: 10,
+        }),
+      (args: { limit: number }) => {
+        const sessions = listSessions().slice(0, args.limit);
+
+        if (sessions.length === 0) {
+          console.log(style.muted("Nenhuma sessao encontrada"));
+          return;
+        }
+
+        console.log(style.header(`┌─ Sessoes (${sessions.length}) ───────────────────────────`));
+        for (const s of sessions) {
+          const date = new Date(s.updatedAt).toLocaleString("pt-BR");
+          console.log(`│ ${style.code(s.id.slice(0, 8))}... ${style.highlight(s.title)}`);
+          console.log(`│   ${style.muted(`${date} · ${s.model} · ${s.messages.length} msgs`)}`);
+          console.log(`│`);
+        }
+        console.log(style.header("└───────────────────────────────────────────"));
+      }
+    )
+    .command(
+      "show <id>",
+      "Exibe detalhes de uma sessao",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (y: any) =>
+        y.positional("id", {
+          describe: "ID da sessao",
+          type: "string",
+          demandOption: true,
+        }),
+      (args: { id: string }) => {
+        const session = getSession(args.id);
+        if (!session) {
+          console.error(style.error("✗ Sessao nao encontrada"));
+          process.exit(1);
+        }
+
+        console.log(style.header("┌─ Sessao ─────────────────────────────────"));
+        console.log(`│ ID: ${style.code(session.id)}`);
+        console.log(`│ Titulo: ${style.highlight(session.title)}`);
+        console.log(`│ Modelo: ${style.code(session.model)}`);
+        console.log(`│ Mensagens: ${session.messages.length}`);
+        console.log(`│ Criada: ${new Date(session.createdAt).toLocaleString("pt-BR")}`);
+        console.log(style.header("├─ Mensagens ──────────────────────────────"));
+
+        for (const msg of session.messages) {
+          const role = msg.role === "user" ? "Voce" : msg.role === "assistant" ? "Phantom" : "Sistema";
+          const color = msg.role === "user" ? style.label : msg.role === "assistant" ? style.primary : style.warning;
+          const preview = msg.content.slice(0, 200) + (msg.content.length > 200 ? "..." : "");
+          console.log(color(`${role}: ${preview}`));
+          console.log("");
+        }
+        console.log(style.header("└───────────────────────────────────────────"));
+      }
+    )
+    .command(
+      "delete <id>",
+      "Deleta uma sessao",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (y: any) =>
+        y.positional("id", {
+          describe: "ID da sessao",
+          type: "string",
+          demandOption: true,
+        }),
+      (args: { id: string }) => {
+        const session = getSession(args.id);
+        if (!session) {
+          console.error(style.error("✗ Sessao nao encontrada"));
+          process.exit(1);
+        }
+        deleteSession(args.id);
+        console.log(style.success(`✓ Sessao "${session.title}" deletada`));
+      }
+    )
+    .demandCommand(1, "Use: phantomcode session <comando>")
+    .help();
+}

package/src/config/manager.ts

@@ -0,0 +1,49 @@
+import Conf from "conf";
+
+interface PhantomConfig {
+  apiKey?: string;
+  defaultModel?: string;
+  theme?: "light" | "dark";
+}
+
+const store = new Conf<PhantomConfig>({
+  projectName: "phantomcode",
+  defaults: {
+    defaultModel: "dogrouter/auto",
+    theme: "dark",
+  },
+});
+
+export function getApiKey(): string {
+  const key = store.get("apiKey");
+  if (!key) throw new Error("API key nao configurada. Use: phantomcode config --set <api-key>");
+  return key;
+}
+
+export function setApiKey(key: string): void {
+  store.set("apiKey", key);
+}
+
+export function removeApiKey(): void {
+  store.delete("apiKey");
+}
+
+export function hasApiKey(): boolean {
+  return store.has("apiKey");
+}
+
+export function getDefaultModel(): string {
+  return store.get("defaultModel", "dogrouter/auto");
+}
+
+export function setDefaultModel(model: string): void {
+  store.set("defaultModel", model);
+}
+
+export function getTheme(): string {
+  return store.get("theme", "dark");
+}
+
+export function getAll(): PhantomConfig {
+  return store.store;
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+#! /usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { style } from "./tui/colors";
+import { handleChat } from "./commands/chat";
+import { handleModels } from "./commands/models";
+import { buildConfigCommand } from "./commands/config";
+import { buildSessionCommand } from "./commands/session";
+import { runInteractive } from "./commands/interactive";
+
+const pkg: { version: string } = require("../package.json");
+
+yargs(hideBin(process.argv))
+  .scriptName("phantomcode")
+  .version(`PhantomCode v${pkg.version}`)
+  .command(
+    "chat <message>",
+    "Envia mensagem para IA via DogRouter",
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ((y: any) =>
+      y
+        .positional("message", {
+          describe: "Mensagem a ser enviada",
+          type: "string",
+          demandOption: true,
+        })
+        .option("model", {
+          alias: "m",
+          describe: "Modelo a usar",
+          type: "string",
+        })
+        .option("system", {
+          alias: "s",
+          describe: "System prompt",
+          type: "string",
+        })
+        .option("session", {
+          describe: "ID de sessao para continuar",
+          type: "string",
+        })
+        .option("no-save", {
+          describe: "Nao salvar em sessao",
+          type: "boolean",
+          default: false,
+        })) as any,
+    handleChat as any
+  )
+  .command(
+    "interactive",
+    "Modo interativo com historico de conversa",
+    ((y: any) =>
+      y
+        .option("model", { alias: "m", describe: "Modelo a usar", type: "string" })
+        .option("system", { alias: "s", describe: "System prompt", type: "string" })
+        .option("session", { describe: "ID de sessao para continuar", type: "string" })) as any,
+    runInteractive as any
+  )
+  .command(
+    "models",
+    "Lista modelos disponiveis via DogRouter",
+    ((y: any) =>
+      y.option("search", {
+        alias: "s",
+        describe: "Filtrar modelos por nome",
+        type: "string",
+      })) as any,
+    handleModels as any
+  )
+  .command("config", "Gerencia configuracoes do CLI", buildConfigCommand as any, () => {})
+  .command("session", "Gerencia sessoes de conversa", buildSessionCommand as any, () => {})
+  .command(
+    "$0",
+    "",
+    () => {},
+    () => {
+      printWelcome();
+    }
+  )
+  .demandCommand(0)
+  .strict()
+  .help()
+  .fail((msg: string, err: Error) => {
+    if (err) {
+      console.error(style.error(`\n✗ ${err.message}`));
+    } else {
+      console.error(style.error(`\n✗ ${msg}`));
+      console.log(style.muted("\n  Use: phantomcode --help para ver os comandos disponiveis"));
+    }
+    process.exit(1);
+  })
+  .parse();
+
+function printWelcome(): void {
+  console.log(style.header(`
+  ╔══════════════════════════════════════════════╗
+  ║         ✦ PhantomCode - CLI v${pkg.version} ✦         ║
+  ║       DogRouter AI Integration Platform      ║
+  ╚══════════════════════════════════════════════╝`));
+  console.log(style.muted("\n  Um CLI poderoso para interagir com modelos de IA via DogRouter."));
+  console.log(style.muted("  Roteamento inteligente, multi-modelo, sessoes e historico.\n"));
+  console.log(`${style.primary("  USO:")}`);
+  console.log(`    ${style.code("phantomcode chat <mensagem>")}      ${style.muted("Enviar mensagem para IA")}`);
+  console.log(`    ${style.code("phantomcode interactive")}          ${style.muted("Modo interativo")}`);
+  console.log(`    ${style.code("phantomcode models")}               ${style.muted("Listar modelos")}`);
+  console.log(`    ${style.code("phantomcode config set <key>")}     ${style.muted("Configurar API key")}`);
+  console.log(`    ${style.code("phantomcode session list")}         ${style.muted("Listar sessoes")}`);
+  console.log(style.muted(`\n  Documentacao: https://dogrouter.ai\n`));
+}

package/src/provider/dogrouter.ts

@@ -0,0 +1,82 @@
+import OpenAI from "openai";
+
+const BASE_URL = "https://api.dogrouter.ai/v1";
+
+let client: OpenAI | null = null;
+
+function getClient(apiKey: string): OpenAI {
+  if (!client) {
+    client = new OpenAI({ apiKey, baseURL: BASE_URL });
+  }
+  return client;
+}
+
+export interface ChatOptions {
+  model?: string;
+  systemPrompt?: string;
+  temperature?: number;
+  maxTokens?: number;
+  stream?: boolean;
+}
+
+export interface ChatResponse {
+  content: string;
+  model: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+export async function chat(
+  apiKey: string,
+  messages: { role: "user" | "assistant" | "system"; content: string }[],
+  options: ChatOptions = {}
+): Promise<ChatResponse> {
+  const c = getClient(apiKey);
+  const completion = await c.chat.completions.create({
+    model: options.model || "dogrouter/auto",
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    temperature: options.temperature ?? 0.7,
+    max_tokens: options.maxTokens,
+  });
+
+  return {
+    content: completion.choices[0]?.message?.content || "",
+    model: completion.model,
+    usage: completion.usage
+      ? {
+          promptTokens: completion.usage.prompt_tokens,
+          completionTokens: completion.usage.completion_tokens,
+          totalTokens: completion.usage.total_tokens,
+        }
+      : undefined,
+  };
+}
+
+export async function* chatStream(
+  apiKey: string,
+  messages: { role: "user" | "assistant" | "system"; content: string }[],
+  options: ChatOptions = {}
+): AsyncGenerator<string> {
+  const c = getClient(apiKey);
+  const stream = await c.chat.completions.create({
+    model: options.model || "dogrouter/auto",
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    temperature: options.temperature ?? 0.7,
+    max_tokens: options.maxTokens,
+    stream: true,
+  });
+
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content;
+    if (delta) yield delta;
+  }
+}
+
+export async function listModels(apiKey: string): Promise<{ id: string; ownedBy: string }[]> {
+  const c = getClient(apiKey);
+  const models = await c.models.list();
+  return models.data.map((m) => ({ id: m.id, ownedBy: m.owned_by || "dogrouter" }));
+}

package/src/session/manager.ts

@@ -0,0 +1,93 @@
+import { v4 as uuid } from "uuid";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+interface Message {
+  role: "user" | "assistant" | "system";
+  content: string;
+  timestamp: number;
+}
+
+interface Session {
+  id: string;
+  title: string;
+  model: string;
+  messages: Message[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+const SESSIONS_DIR = path.join(os.homedir(), ".phantomcode", "sessions");
+
+function ensureDir(): void {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+function sessionPath(id: string): string {
+  return path.join(SESSIONS_DIR, `${id}.json`);
+}
+
+export function createSession(model: string, title = "Nova sessao"): Session {
+  ensureDir();
+  const session: Session = {
+    id: uuid(),
+    title,
+    model,
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+  fs.writeFileSync(sessionPath(session.id), JSON.stringify(session, null, 2));
+  return session;
+}
+
+export function getSession(id: string): Session | null {
+  try {
+    return JSON.parse(fs.readFileSync(sessionPath(id), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function listSessions(): Session[] {
+  ensureDir();
+  const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  return files
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), "utf-8")) as Session;
+      } catch {
+        return null;
+      }
+    })
+    .filter((s): s is Session => s !== null)
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+export function addMessage(sessionId: string, role: Message["role"], content: string): Session | null {
+  const session = getSession(sessionId);
+  if (!session) return null;
+
+  session.messages.push({ role, content, timestamp: Date.now() });
+  session.updatedAt = Date.now();
+
+  if (session.messages.length === 1) {
+    session.title = content.slice(0, 50) + (content.length > 50 ? "..." : "");
+  }
+
+  fs.writeFileSync(sessionPath(sessionId), JSON.stringify(session, null, 2));
+  return session;
+}
+
+export function deleteSession(id: string): void {
+  const p = sessionPath(id);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}
+
+export function getMessages(sessionId: string): Message[] {
+  const session = getSession(sessionId);
+  return session?.messages || [];
+}

package/src/tui/colors.ts

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import { getTheme } from "../config/manager";
+
+const theme = {
+  light: {
+    primary: chalk.hex("#2563eb"),
+    success: chalk.hex("#16a34a"),
+    warning: chalk.hex("#ea580c"),
+    error: chalk.hex("#dc2626"),
+    muted: chalk.hex("#64748b"),
+    highlight: chalk.hex("#1e293b"),
+    label: chalk.hex("#475569"),
+  },
+  dark: {
+    primary: chalk.hex("#60a5fa"),
+    success: chalk.hex("#4ade80"),
+    warning: chalk.hex("#fb923c"),
+    error: chalk.hex("#f87171"),
+    muted: chalk.hex("#94a3b8"),
+    highlight: chalk.hex("#e2e8f0"),
+    label: chalk.hex("#cbd5e1"),
+  },
+};
+
+function getColors() {
+  const t = getTheme() === "light" ? theme.light : theme.dark;
+  return t;
+}
+
+export const style = {
+  primary: (s: string) => getColors().primary(s),
+  success: (s: string) => getColors().success(s),
+  warning: (s: string) => getColors().warning(s),
+  error: (s: string) => getColors().error(s),
+  muted: (s: string) => getColors().muted(s),
+  highlight: (s: string) => getColors().highlight(s),
+  label: (s: string) => getColors().label(s),
+  bold: chalk.bold,
+  dim: chalk.dim,
+  code: (s: string) => chalk.cyan(s),
+  header: (s: string) => chalk.bold.hex("#60a5fa")(s),
+  separator: () => chalk.dim("─".repeat(process.stdout.columns || 60)),
+};

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022", "dom"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}