macroclaw 0.2.0 → 0.4.0

package/src/index.ts

@@ -1,58 +1,48 @@
 import { cpSync, existsSync, readdirSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { createInterface } from "node:readline";
 import { App, type AppConfig } from "./app";
 import { createLogger, initLogger } from "./logger";
-import { applyEnvOverrides, loadSettings, printSettings, saveSettings } from "./settings";
-import { runSetupWizard } from "./setup";
+import { applyEnvOverrides, loadSettings, printSettings } from "./settings";
 
-await initLogger();
-const log = createLogger("index");
+export async function start(): Promise<void> {
+  const log = createLogger("index");
 
-const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
+  const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
 
-let settings = loadSettings(defaultDir);
+  const settings = loadSettings(defaultDir);
 
-if (!settings) {
-  log.info("No settings.json found, starting setup wizard");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const io = {
-    ask: (question: string): Promise<string> =>
-      new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim()))),
-    write: (msg: string) => process.stdout.write(msg),
-  };
-  settings = await runSetupWizard(io);
-  rl.close();
-  saveSettings(settings, defaultDir);
-  log.info("Settings saved");
-}
+  if (!settings) {
+    log.error("No settings found. Run `macroclaw setup` first.");
+    process.exit(1);
+  }
 
-const { settings: resolved, overrides } = applyEnvOverrides(settings);
-settings = resolved;
+  const { settings: resolved, overrides } = applyEnvOverrides(settings);
 
-printSettings(settings, overrides);
+  await initLogger({ level: resolved.logLevel, pinoramaUrl: resolved.pinoramaUrl });
+  printSettings(resolved, overrides);
 
-const workspace = resolve(settings.workspace.replace(/^~/, process.env.HOME || "~"));
+  const workspace = resolve(resolved.workspace.replace(/^~/, process.env.HOME || "~"));
 
-function initWorkspace(workspace: string) {
-  const templateDir = join(dirname(import.meta.dir), "workspace-template");
-  const exists = existsSync(workspace);
-  const empty = exists && readdirSync(workspace).length === 0;
+  function initWorkspace(workspace: string) {
+    const templateDir = join(dirname(import.meta.dir), "workspace-template");
+    const exists = existsSync(workspace);
+    const empty = exists && readdirSync(workspace).length === 0;
 
-  if (!exists || empty) {
-    log.info({ workspace }, "Initializing workspace from template");
-    cpSync(templateDir, workspace, { recursive: true });
-    log.info("Workspace initialized");
+    if (!exists || empty) {
+      log.info({ workspace }, "Initializing workspace from template");
+      cpSync(templateDir, workspace, { recursive: true });
+      log.info("Workspace initialized");
+    }
   }
-}
 
-initWorkspace(workspace);
+  initWorkspace(workspace);
 
-const config: AppConfig = {
-  botToken: settings.botToken,
-  authorizedChatId: settings.chatId,
-  workspace,
-  model: settings.model,
-};
+  const config: AppConfig = {
+    botToken: resolved.botToken,
+    authorizedChatId: resolved.chatId,
+    workspace,
+    model: resolved.model,
+  };
 
-new App(config).start();
+  new App(config).start();
+}

package/src/logger.test.ts

@@ -17,17 +17,28 @@ describe("createLogger", () => {
 });
 
 describe("initLogger", () => {
-  it("adds pinorama transport when PINORAMA_URL is set", async () => {
-    process.env.PINORAMA_URL = "http://localhost:6200/pinorama";
+  it("does nothing when called without opts", async () => {
+    mockPinoramaTransport.mockClear();
     await initLogger();
-    expect(mockPinoramaTransport).toHaveBeenCalledWith({ url: "http://localhost:6200/pinorama" });
-    delete process.env.PINORAMA_URL;
+    expect(mockPinoramaTransport).not.toHaveBeenCalled();
+  });
+
+  it("sets log level from opts", async () => {
+    const log = createLogger("opts-level");
+    await initLogger({ level: "warn" });
+    expect(log.level).toBe("warn");
+    await initLogger({ level: "info" }); // restore
   });
 
-  it("does nothing when PINORAMA_URL is not set", async () => {
-    delete process.env.PINORAMA_URL;
+  it("adds pinorama transport from opts", async () => {
     mockPinoramaTransport.mockClear();
-    await initLogger();
+    await initLogger({ pinoramaUrl: "http://example.com/pinorama" });
+    expect(mockPinoramaTransport).toHaveBeenCalledWith({ url: "http://example.com/pinorama" });
+  });
+
+  it("does not add duplicate pinorama transport on second call", async () => {
+    mockPinoramaTransport.mockClear();
+    await initLogger({ pinoramaUrl: "http://example.com/pinorama" });
     expect(mockPinoramaTransport).not.toHaveBeenCalled();
   });
 });

package/src/logger.ts

@@ -6,20 +6,30 @@ const prettyStream = pretty({
 	messageFormat: "[{module}] {msg}",
 });
 
-const level = (process.env.LOG_LEVEL || "info") as pino.Level;
+const defaultLevel = (process.env.LOG_LEVEL || "info") as pino.Level;
 
-const streams: pino.StreamEntry[] = [{ level, stream: prettyStream }];
+// Streams accept all levels; logger.level is the sole gate
+const streams: pino.StreamEntry[] = [{ level: "trace", stream: prettyStream }];
 
 const logger = pino(
-	{ level: process.env.LOG_LEVEL || "info" },
+	{ level: defaultLevel },
 	pino.multistream(streams),
 );
 
-export async function initLogger(): Promise<void> {
-	const pinoramaUrl = process.env.PINORAMA_URL;
-	if (pinoramaUrl) {
+export interface LoggerOptions {
+	level?: pino.Level;
+	pinoramaUrl?: string;
+}
+
+let pinoramaAdded = false;
+
+export async function initLogger(opts?: LoggerOptions): Promise<void> {
+	if (opts?.level) logger.level = opts.level;
+
+	if (opts?.pinoramaUrl && !pinoramaAdded) {
 		const { default: pinoramaTransport } = await import("pinorama-transport");
-		streams.push({ level, stream: pinoramaTransport({ url: pinoramaUrl }) });
+		streams.push({ level: "trace", stream: pinoramaTransport({ url: opts.pinoramaUrl }) });
+		pinoramaAdded = true;
 	}
 }