@fastino-ai/pioneer-cli 0.2.9 → 0.2.11

package/src/telemetry.ts

@@ -1,173 +0,0 @@
-/**
- * Telemetry module for Pioneer CLI.
- * Opt-in anonymous analytics sent via Pioneer API → Datadog.
- *
- * Privacy-first:
- * - Disabled by default, requires explicit opt-in
- * - Anonymous UUID per installation (no PII)
- * - Only tracks feature usage, never user content
- */
-
-import crypto from "crypto";
-import os from "os";
-import { loadConfig, saveConfig, getBaseUrl, getApiKey } from "./config.js";
-import packageJson from "../package.json";
-
-// Telemetry endpoint on Pioneer API (forwards to Datadog)
-const TELEMETRY_PATH = "/cli/telemetry";
-
-/**
- * Get or create an anonymous installation ID.
- */
-function getAnonymousId(): string {
-  const config = loadConfig();
-
-  if (config.telemetry?.anonymousId) {
-    return config.telemetry.anonymousId;
-  }
-
-  const anonymousId = crypto.randomUUID();
-  saveConfig({
-    telemetry: {
-      ...config.telemetry,
-      anonymousId,
-    },
-  });
-
-  return anonymousId;
-}
-
-/**
- * Check if telemetry is enabled.
- */
-export function isEnabled(): boolean {
-  if (process.env.PIONEER_TELEMETRY === "false") return false;
-  if (process.env.PIONEER_TELEMETRY === "true") return true;
-
-  const config = loadConfig();
-  return config.telemetry?.enabled === true;
-}
-
-/**
- * Check if user has made a telemetry choice.
- */
-export function hasChosenTelemetry(): boolean {
-  const config = loadConfig();
-  return config.telemetry?.enabled !== undefined;
-}
-
-/**
- * Enable or disable telemetry.
- */
-export function setEnabled(enabled: boolean): void {
-  const config = loadConfig();
-  saveConfig({
-    telemetry: {
-      ...config.telemetry,
-      enabled,
-      anonymousId: enabled
-        ? (config.telemetry?.anonymousId || crypto.randomUUID())
-        : config.telemetry?.anonymousId,
-    },
-  });
-}
-
-/**
- * Send event to Pioneer API telemetry endpoint.
- * Fire-and-forget, never blocks or throws.
- */
-function sendEvent(event: string, properties?: Record<string, unknown>): void {
-  if (!isEnabled()) {
-    return;
-  }
-
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const url = `${baseUrl}${TELEMETRY_PATH}`;
-  const apiKey = getApiKey();
-
-  const payload = {
-    event,
-    installation_id: getAnonymousId(),
-    cli_version: packageJson.version,
-    os_type: os.type(),
-    os_platform: os.platform(),
-    os_arch: os.arch(),
-    ...properties,
-  };
-
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-
-  try {
-    fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-    }).catch(() => {});
-  } catch {
-    // Silently fail
-  }
-}
-
-/**
- * Track an event.
- */
-export function track(event: string, properties?: Record<string, unknown>): void {
-  sendEvent(event, properties);
-}
-
-/**
- * Track CLI command invocation.
- */
-export function trackCommand(command: string, subcommand?: string): void {
-  track("cli_command", { command, subcommand });
-}
-
-/**
- * Track dataset generation.
- */
-export function trackDatasetGenerate(
-  type: "ner" | "classification" | "custom",
-  numExamples: number,
-  saveToRemote: boolean
-): void {
-  track("dataset_generate", { type, num_examples: numExamples, save_to_remote: saveToRemote });
-}
-
-/**
- * Track chat session start.
- */
-export function trackChatSessionStart(provider: string, model: string): void {
-  track("chat_session_start", { provider, model });
-}
-
-/**
- * Track chat session end.
- */
-export function trackChatSessionEnd(
-  durationMs: number,
-  messageCount: number,
-  toolCallCount: number
-): void {
-  track("chat_session_end", {
-    duration_seconds: Math.round(durationMs / 1000),
-    message_count: messageCount,
-    tool_call_count: toolCallCount,
-  });
-}
-
-/**
- * Track job creation.
- */
-export function trackJobCreate(baseModel: string): void {
-  track("job_create", { base_model: baseModel });
-}
-
-/**
- * Track model download.
- */
-export function trackModelDownload(): void {
-  track("model_download");
-}

package/src/tests/api.test.ts

@@ -1,104 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import type { DatasetRef, ApiResult } from "../api";
-
-describe("API helper functions", () => {
-  describe("Error formatting and detection", () => {
-    test("should identify 401 as authentication error", () => {
-      // Test the isAuthError logic by checking status codes
-      const authStatuses = [401, 403];
-      authStatuses.forEach(status => {
-        // These status codes should be treated as auth errors
-        expect(status === 401 || status === 403).toBe(true);
-      });
-    });
-
-    test("should identify auth-related error text", () => {
-      const authErrorTexts = [
-        "Authentication failed",
-        "API key invalid",
-        "unauthorized access",
-        "UNAUTHORIZED",
-      ];
-
-      authErrorTexts.forEach(text => {
-        const lowerText = text.toLowerCase();
-        const isAuthError = 
-          lowerText.includes("authentication") ||
-          lowerText.includes("api key") ||
-          lowerText.includes("unauthorized");
-        
-        expect(isAuthError).toBe(true);
-      });
-    });
-
-    test("should not identify non-auth errors", () => {
-      const nonAuthErrors = [
-        "Bad request",
-        "Not found",
-        "Internal server error",
-        "Validation failed",
-      ];
-
-      nonAuthErrors.forEach(text => {
-        const lowerText = text.toLowerCase();
-        const isAuthError = 
-          lowerText.includes("authentication") ||
-          lowerText.includes("api key") ||
-          lowerText.includes("unauthorized");
-        
-        expect(isAuthError).toBe(false);
-      });
-    });
-
-    test("auth error message should include helpful instructions", () => {
-      const expectedParts = [
-        "pioneer auth login",
-        "https://agent.pioneer.ai",
-        "Authentication failed",
-      ];
-
-      // This tests the expected format of formatAuthError()
-      expectedParts.forEach(part => {
-        expect(typeof part).toBe("string");
-        expect(part.length).toBeGreaterThan(0);
-      });
-    });
-  });
-
-  describe("Type definitions", () => {
-    test("DatasetRef should have name and version", () => {
-      const ref: DatasetRef = { 
-        name: "test-dataset", 
-        version: "v1" 
-      };
-      
-      expect(ref.name).toBe("test-dataset");
-      expect(ref.version).toBe("v1");
-    });
-
-    test("ApiResult should support success with data", () => {
-      const result: ApiResult<{ message: string }> = {
-        ok: true,
-        status: 200,
-        data: { message: "success" }
-      };
-
-      expect(result.ok).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data?.message).toBe("success");
-    });
-
-    test("ApiResult should support error without data", () => {
-      const result: ApiResult = {
-        ok: false,
-        status: 400,
-        error: "Bad request"
-      };
-
-      expect(result.ok).toBe(false);
-      expect(result.status).toBe(400);
-      expect(result.error).toBe("Bad request");
-      expect(result.data).toBeUndefined();
-    });
-  });
-});

package/src/tests/config-functions.test.ts

@@ -1,163 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  loadConfig,
-  saveConfig,
-  clearApiKey,
-  getApiKey,
-  getBaseUrl,
-  getMleModel,
-  setMleModel,
-  getConfigDir,
-  getHfToken,
-  setHfToken,
-  clearHfToken,
-  DEFAULT_BASE_URL,
-} from "../config";
-
-describe("Config file operations", () => {
-  const testConfigDir = path.join(os.tmpdir(), `.pioneer-test-${Date.now()}`);
-  const testConfigFile = path.join(testConfigDir, "config.json");
-  let originalHome: string | undefined;
-  let originalApiKey: string | undefined;
-  let originalApiUrl: string | undefined;
-  let originalHfToken: string | undefined;
-
-  beforeEach(() => {
-    // Save original env vars
-    originalHome = process.env.HOME;
-    originalApiKey = process.env.PIONEER_API_KEY;
-    originalApiUrl = process.env.PIONEER_API_URL;
-    originalHfToken = process.env.HF_TOKEN;
-
-    // Clear env vars for testing
-    delete process.env.PIONEER_API_KEY;
-    delete process.env.PIONEER_API_URL;
-    delete process.env.HF_TOKEN;
-
-    // Create test directory
-    if (!fs.existsSync(testConfigDir)) {
-      fs.mkdirSync(testConfigDir, { recursive: true });
-    }
-
-    // Mock the config directory to use our test directory
-    process.env.HOME = os.tmpdir();
-  });
-
-  afterEach(() => {
-    // Restore original env vars
-    if (originalHome !== undefined) {
-      process.env.HOME = originalHome;
-    }
-    if (originalApiKey !== undefined) {
-      process.env.PIONEER_API_KEY = originalApiKey;
-    }
-    if (originalApiUrl !== undefined) {
-      process.env.PIONEER_API_URL = originalApiUrl;
-    }
-    if (originalHfToken !== undefined) {
-      process.env.HF_TOKEN = originalHfToken;
-    }
-
-    // Clean up test directory
-    if (fs.existsSync(testConfigDir)) {
-      fs.rmSync(testConfigDir, { recursive: true, force: true });
-    }
-  });
-
-  describe("loadConfig", () => {
-    test("should return config object (may have defaults)", () => {
-      const config = loadConfig();
-      expect(typeof config).toBe("object");
-      expect(config).toBeDefined();
-    });
-  });
-
-  describe("saveConfig and persistence", () => {
-    test("should save and load config", () => {
-      // This test interacts with actual config, so we test the behavior
-      const testModel = "claude-sonnet-4-5-20250929";
-      setMleModel(testModel);
-      
-      const model = getMleModel();
-      expect(model).toBe(testModel);
-    });
-
-    test("should handle HF token operations", () => {
-      // Set token
-      setHfToken("test-token-12345");
-      const token = getHfToken();
-      expect(token).toBe("test-token-12345");
-
-      // Clear token
-      clearHfToken();
-      const clearedToken = getHfToken();
-      expect(clearedToken).toBeUndefined();
-    });
-  });
-
-  describe("getBaseUrl", () => {
-    test("should return default base URL when not configured", () => {
-      const baseUrl = getBaseUrl();
-      expect(baseUrl).toBe(DEFAULT_BASE_URL);
-    });
-
-    test("should prioritize environment variable over default", () => {
-      process.env.PIONEER_API_URL = "https://test.example.com";
-      const baseUrl = getBaseUrl();
-      expect(baseUrl).toBe("https://test.example.com");
-    });
-  });
-
-  describe("getApiKey", () => {
-    test("should return undefined when no API key is set", () => {
-      const apiKey = getApiKey();
-      expect(apiKey).toBeUndefined();
-    });
-
-    test("should prioritize environment variable", () => {
-      process.env.PIONEER_API_KEY = "test-key-from-env";
-      const apiKey = getApiKey();
-      expect(apiKey).toBe("test-key-from-env");
-    });
-  });
-
-  describe("getMleModel", () => {
-    test("should return configured model or undefined", () => {
-      const model = getMleModel();
-      // May be undefined or a valid model string depending on config state
-      if (model !== undefined) {
-        expect(typeof model).toBe("string");
-      }
-    });
-  });
-
-  describe("getConfigDir", () => {
-    test("should return a valid directory path", () => {
-      const dir = getConfigDir();
-      expect(typeof dir).toBe("string");
-      expect(dir.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe("getHfToken", () => {
-    test("should return undefined when no token is set", () => {
-      const token = getHfToken();
-      expect(token).toBeUndefined();
-    });
-
-    test("should prioritize explicit token parameter", () => {
-      process.env.HF_TOKEN = "env-token";
-      const token = getHfToken("explicit-token");
-      expect(token).toBe("explicit-token");
-    });
-
-    test("should use environment variable when no explicit token", () => {
-      process.env.HF_TOKEN = "env-token";
-      const token = getHfToken();
-      expect(token).toBe("env-token");
-    });
-  });
-});

package/src/tests/config.test.ts

@@ -1,33 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { DEFAULT_BASE_URL, DEFAULT_MLE_MODEL, AVAILABLE_MLE_MODELS } from "../config";
-
-describe("Config defaults", () => {
-  test("DEFAULT_BASE_URL should be defined", () => {
-    expect(DEFAULT_BASE_URL).toBeDefined();
-    expect(typeof DEFAULT_BASE_URL).toBe("string");
-  });
-
-  test("DEFAULT_MLE_MODEL should be defined", () => {
-    expect(DEFAULT_MLE_MODEL).toBeDefined();
-    expect(typeof DEFAULT_MLE_MODEL).toBe("string");
-  });
-
-  test("AVAILABLE_MLE_MODELS should contain default model", () => {
-    const modelIds = AVAILABLE_MLE_MODELS.map(m => m.id);
-    expect(modelIds).toContain(DEFAULT_MLE_MODEL);
-  });
-
-  test("AVAILABLE_MLE_MODELS should have valid structure", () => {
-    expect(Array.isArray(AVAILABLE_MLE_MODELS)).toBe(true);
-    expect(AVAILABLE_MLE_MODELS.length).toBeGreaterThan(0);
-    
-    AVAILABLE_MLE_MODELS.forEach(model => {
-      expect(model).toHaveProperty("id");
-      expect(model).toHaveProperty("name");
-      expect(model).toHaveProperty("description");
-      expect(typeof model.id).toBe("string");
-      expect(typeof model.name).toBe("string");
-      expect(typeof model.description).toBe("string");
-    });
-  });
-});

package/src/tests/file-resolver-edge-cases.test.ts

@@ -1,92 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { FileResolver, getFileResolver } from "../utils/FileResolver";
-import * as path from "path";
-
-describe("FileResolver edge cases", () => {
-  let resolver: FileResolver;
-
-  beforeEach(() => {
-    resolver = new FileResolver(process.cwd());
-  });
-
-  describe("resolve edge cases", () => {
-    test("should handle message with no @ references", () => {
-      const message = "This is a plain message without any file references";
-      const result = resolver.resolve(message);
-
-      expect(result.references.length).toBe(0);
-      expect(result.contextBlock).toBe("");
-      expect(result.cleanMessage).toBe(message);
-    });
-
-    test("should handle non-existent file references", () => {
-      const message = "Check @non-existent-file-12345.txt";
-      const result = resolver.resolve(message);
-
-      expect(result.references.length).toBe(1);
-      expect(result.references[0].exists).toBe(false);
-      expect(result.references[0].error).toBeDefined();
-    });
-
-    test("should handle absolute paths", () => {
-      const absolutePath = path.resolve(process.cwd(), "package.json");
-      const message = `Check @${absolutePath}`;
-      const result = resolver.resolve(message);
-
-      expect(result.references.length).toBeGreaterThanOrEqual(1);
-    });
-
-    test("should handle existing file and include content", () => {
-      const message = "Check @package.json for version";
-      const result = resolver.resolve(message);
-
-      if (result.references.length > 0 && result.references[0].exists) {
-        expect(result.references[0].content).toBeDefined();
-        expect(result.references[0].isDirectory).toBe(false);
-        expect(result.contextBlock.length).toBeGreaterThan(0);
-      }
-    });
-
-    test("should handle directory references", () => {
-      const message = "Check @src/ directory";
-      const result = resolver.resolve(message);
-
-      if (result.references.length > 0 && result.references[0].exists) {
-        expect(result.references[0].isDirectory).toBe(true);
-      }
-    });
-  });
-
-  describe("getSuggestions edge cases", () => {
-    test("should return empty array for non-existent directory", () => {
-      const suggestions = resolver.getSuggestions("non-existent-dir-12345/");
-      expect(suggestions).toEqual([]);
-    });
-
-    test("should handle empty partial with custom limit", () => {
-      const suggestions = resolver.getSuggestions("", 3);
-      expect(suggestions.length).toBeLessThanOrEqual(3);
-    });
-
-    test("should filter by prefix correctly", () => {
-      const suggestions = resolver.getSuggestions("pack");
-      const hasPackageJson = suggestions.some(s => s.includes("package"));
-      expect(hasPackageJson).toBe(true);
-    });
-  });
-
-  describe("getFileResolver singleton", () => {
-    test("should return same instance when called multiple times", () => {
-      const resolver1 = getFileResolver();
-      const resolver2 = getFileResolver();
-      expect(resolver1).toBe(resolver2);
-    });
-
-    test("should create new instance when basePath is provided", () => {
-      const resolver1 = getFileResolver();
-      const resolver2 = getFileResolver("/custom/path");
-      // Singleton is updated, so both point to the same updated instance
-      expect(resolver2).toBeDefined();
-    });
-  });
-});

package/src/tests/telemetry.test.ts

@@ -1,111 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
-import {
-  isEnabled,
-  hasChosenTelemetry,
-  setEnabled,
-  track,
-  trackCommand,
-  trackDatasetGenerate,
-  trackChatSessionStart,
-  trackChatSessionEnd,
-  trackJobCreate,
-  trackModelDownload,
-} from "../telemetry";
-
-describe("Telemetry", () => {
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.PIONEER_TELEMETRY;
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.PIONEER_TELEMETRY = originalEnv;
-    } else {
-      delete process.env.PIONEER_TELEMETRY;
-    }
-  });
-
-  describe("isEnabled", () => {
-    test("should respect PIONEER_TELEMETRY=false env var", () => {
-      process.env.PIONEER_TELEMETRY = "false";
-      expect(isEnabled()).toBe(false);
-    });
-
-    test("should respect PIONEER_TELEMETRY=true env var", () => {
-      process.env.PIONEER_TELEMETRY = "true";
-      expect(isEnabled()).toBe(true);
-    });
-
-    test("should check config when env var not set", () => {
-      delete process.env.PIONEER_TELEMETRY;
-      const enabled = isEnabled();
-      expect(typeof enabled).toBe("boolean");
-    });
-  });
-
-  describe("hasChosenTelemetry", () => {
-    test("should return boolean", () => {
-      const hasChosen = hasChosenTelemetry();
-      expect(typeof hasChosen).toBe("boolean");
-    });
-  });
-
-  describe("setEnabled", () => {
-    test("should enable telemetry", () => {
-      setEnabled(true);
-      // If env var not set, should read from config
-      delete process.env.PIONEER_TELEMETRY;
-      expect(hasChosenTelemetry()).toBe(true);
-    });
-
-    test("should disable telemetry", () => {
-      setEnabled(false);
-      delete process.env.PIONEER_TELEMETRY;
-      expect(hasChosenTelemetry()).toBe(true);
-    });
-  });
-
-  describe("track functions", () => {
-    test("track should not throw when telemetry disabled", () => {
-      process.env.PIONEER_TELEMETRY = "false";
-      expect(() => track("test_event", { prop: "value" })).not.toThrow();
-    });
-
-    test("track should not throw when telemetry enabled", () => {
-      process.env.PIONEER_TELEMETRY = "true";
-      expect(() => track("test_event", { prop: "value" })).not.toThrow();
-    });
-
-    test("trackCommand should accept command and subcommand", () => {
-      expect(() => trackCommand("datasets", "list")).not.toThrow();
-      expect(() => trackCommand("auth", undefined)).not.toThrow();
-    });
-
-    test("trackDatasetGenerate should accept all params", () => {
-      expect(() => trackDatasetGenerate("ner", 100, true)).not.toThrow();
-      expect(() => trackDatasetGenerate("classification", 50, false)).not.toThrow();
-      expect(() => trackDatasetGenerate("custom", 25, true)).not.toThrow();
-    });
-
-    test("trackChatSessionStart should accept provider and model", () => {
-      expect(() => trackChatSessionStart("openai", "gpt-4")).not.toThrow();
-      expect(() => trackChatSessionStart("anthropic", "claude-3")).not.toThrow();
-    });
-
-    test("trackChatSessionEnd should accept session metrics", () => {
-      expect(() => trackChatSessionEnd(60000, 10, 5)).not.toThrow();
-      expect(() => trackChatSessionEnd(0, 0, 0)).not.toThrow();
-    });
-
-    test("trackJobCreate should accept base model", () => {
-      expect(() => trackJobCreate("gliner_small")).not.toThrow();
-      expect(() => trackJobCreate("gliner_large")).not.toThrow();
-    });
-
-    test("trackModelDownload should work without params", () => {
-      expect(() => trackModelDownload()).not.toThrow();
-    });
-  });
-});