@townco/core 0.0.2

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@townco/core",
+  "type": "module",
+  "version": "0.0.2",
+  "description": "core",
+  "license": "UNLICENSED",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": "github:townco/town",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@townco/tsconfig": "0.1.21"
+  },
+  "scripts": {
+    "build": "tsc",
+    "check": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./logger.js";

package/src/logger.ts

@@ -0,0 +1,253 @@
+/**
+ * Browser-compatible logger
+ * Outputs structured JSON logs to console with color-coding
+ * Also captures logs to a global store for in-app viewing
+ * In Node.js environment with logsDir option, also writes to .logs/ directory
+ */
+
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+
+// Check if running in Node.js
+const isNode = typeof process !== "undefined" && process.versions?.node;
+
+// Global logs directory configuration (set once at app startup for TUI)
+let globalLogsDir: string | undefined;
+
+export interface LogEntry {
+  id: string;
+  timestamp: string;
+  level: LogLevel;
+  service: string;
+  message: string;
+  metadata?: Record<string, unknown>;
+}
+
+// Global log store
+const globalLogStore: LogEntry[] = [];
+let logIdCounter = 0;
+
+/**
+ * Get all captured logs
+ */
+export function getCapturedLogs(): LogEntry[] {
+  return [...globalLogStore];
+}
+
+/**
+ * Clear all captured logs
+ */
+export function clearCapturedLogs(): void {
+  globalLogStore.length = 0;
+}
+
+/**
+ * Subscribe to log updates
+ */
+type LogSubscriber = (entry: LogEntry) => void;
+const logSubscribers: Set<LogSubscriber> = new Set();
+
+export function subscribeToLogs(callback: LogSubscriber): () => void {
+  logSubscribers.add(callback);
+  return () => logSubscribers.delete(callback);
+}
+
+function notifyLogSubscribers(entry: LogEntry): void {
+  for (const callback of logSubscribers) {
+    callback(entry);
+  }
+}
+
+/**
+ * Configure global logs directory for file writing
+ * Must be called before creating any loggers (typically at TUI startup)
+ */
+export function configureLogsDir(logsDir: string): void {
+  globalLogsDir = logsDir;
+}
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5,
+};
+
+const _LOG_COLORS: Record<LogLevel, string> = {
+  trace: "#6B7280", // gray
+  debug: "#3B82F6", // blue
+  info: "#10B981", // green
+  warn: "#F59E0B", // orange
+  error: "#EF4444", // red
+  fatal: "#DC2626", // dark red
+};
+
+const _LOG_STYLES: Record<LogLevel, string> = {
+  trace: "color: #6B7280",
+  debug: "color: #3B82F6; font-weight: bold",
+  info: "color: #10B981; font-weight: bold",
+  warn: "color: #F59E0B; font-weight: bold",
+  error: "color: #EF4444; font-weight: bold",
+  fatal: "color: #DC2626; font-weight: bold; background: #FEE2E2",
+};
+
+export class Logger {
+  private service: string;
+  private minLevel: LogLevel;
+  private logFilePath?: string;
+  private logsDir?: string;
+  private writeQueue: string[] = [];
+  private isWriting = false;
+
+  constructor(service: string, minLevel: LogLevel = "debug") {
+    this.service = service;
+    this.minLevel = minLevel;
+
+    // In production, suppress trace and debug logs
+    if (
+      typeof process !== "undefined" &&
+      process.env?.NODE_ENV === "production"
+    ) {
+      this.minLevel = "info";
+    }
+
+    // Note: File logging setup is done lazily in log() method
+    // This allows loggers created before configureLogsDir() to still write to files
+  }
+
+  private setupFileLogging(): void {
+    if (!isNode || !globalLogsDir) return;
+
+    try {
+      // Dynamic import for Node.js modules
+      const path = require("node:path");
+      const fs = require("node:fs");
+
+      this.logsDir = globalLogsDir;
+      this.logFilePath = path.join(this.logsDir, `${this.service}.log`);
+
+      // Create logs directory if it doesn't exist
+      if (!fs.existsSync(this.logsDir)) {
+        fs.mkdirSync(this.logsDir, { recursive: true });
+      }
+    } catch (_error) {
+      // Silently fail if we can't set up file logging
+    }
+  }
+
+  private async writeToFile(content: string): Promise<void> {
+    if (!this.logFilePath || !isNode) return;
+
+    this.writeQueue.push(content);
+
+    if (this.isWriting) {
+      return;
+    }
+
+    this.isWriting = true;
+
+    while (this.writeQueue.length > 0) {
+      const batch = this.writeQueue.splice(0, this.writeQueue.length);
+      const data = `${batch.join("\n")}\n`;
+
+      try {
+        // Dynamic import for Node.js modules
+        const fs = require("node:fs");
+        await fs.promises.appendFile(this.logFilePath, data, "utf-8");
+      } catch (_error) {
+        // Silently fail
+      }
+    }
+
+    this.isWriting = false;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
+  }
+
+  private log(
+    level: LogLevel,
+    message: string,
+    metadata?: Record<string, unknown>,
+  ): void {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+
+    const entry: LogEntry = {
+      id: `log_${++logIdCounter}`,
+      timestamp: new Date().toISOString(),
+      level,
+      service: this.service,
+      message,
+      ...(metadata && { metadata }),
+    };
+
+    // Store in global log store
+    globalLogStore.push(entry);
+
+    // Notify subscribers
+    notifyLogSubscribers(entry);
+
+    // Write to file in Node.js (for logs tab to read)
+    // Lazily set up file logging if globalLogsDir was configured after this logger was created
+    if (isNode && !this.logFilePath && globalLogsDir) {
+      this.setupFileLogging();
+    }
+
+    if (isNode && this.logFilePath) {
+      // Write as JSON without the id field (to match expected format)
+      const fileEntry = {
+        timestamp: entry.timestamp,
+        level: entry.level,
+        service: entry.service,
+        message: entry.message,
+        ...(entry.metadata && { metadata: entry.metadata }),
+      };
+      this.writeToFile(JSON.stringify(fileEntry)).catch(() => {
+        // Silently fail
+      });
+    }
+
+    // No console output - logs are only captured and displayed in UI
+    // This prevents logs from polluting stdout/stderr in TUI mode
+  }
+
+  trace(message: string, metadata?: Record<string, unknown>): void {
+    this.log("trace", message, metadata);
+  }
+
+  debug(message: string, metadata?: Record<string, unknown>): void {
+    this.log("debug", message, metadata);
+  }
+
+  info(message: string, metadata?: Record<string, unknown>): void {
+    this.log("info", message, metadata);
+  }
+
+  warn(message: string, metadata?: Record<string, unknown>): void {
+    this.log("warn", message, metadata);
+  }
+
+  error(message: string, metadata?: Record<string, unknown>): void {
+    this.log("error", message, metadata);
+  }
+
+  fatal(message: string, metadata?: Record<string, unknown>): void {
+    this.log("fatal", message, metadata);
+  }
+}
+
+/**
+ * Create a logger instance for a service
+ * @param service - Service name (e.g., "gui", "http-agent", "tui")
+ * @param minLevel - Minimum log level to display (default: "debug")
+ */
+export function createLogger(
+  service: string,
+  minLevel: LogLevel = "debug",
+): Logger {
+  return new Logger(service, minLevel);
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@townco/tsconfig",
+  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", ".sst"]
+}