@joshski/dust 0.1.51 → 0.1.53

package/dist/dust.js

@@ -3386,6 +3386,9 @@ function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, time
       timer = setTimeout(() => {
         resolved = true;
         proc.kill();
+        proc.stdout?.destroy();
+        proc.stderr?.destroy();
+        proc.unref();
         resolve({
           exitCode: 1,
           output: chunks.join(""),
@@ -5131,4 +5134,10 @@ async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
 }
 
 // lib/cli/run.ts
-await wireEntry({ existsSync, statSync: statSync2, readFile: readFile2, writeFile: writeFile2, mkdir: mkdir2, readdir: readdir2, chmod: chmod2 }, { argv: process.argv, cwd: () => process.cwd(), exit: process.exit }, { log: console.log, error: console.error });
+await wireEntry({ existsSync, statSync: statSync2, readFile: readFile2, writeFile: writeFile2, mkdir: mkdir2, readdir: readdir2, chmod: chmod2 }, {
+  argv: process.argv,
+  cwd: () => process.cwd(),
+  exit: (code) => {
+    process.exitCode = code;
+  }
+}, { log: console.log, error: console.error });

package/dist/logging/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Minimal debug logging framework.
+ *
+ * When the DEBUG environment variable is set, matching loggers write
+ * timestamped lines to `<cwd>/log/dust/<scope>.log`.
+ *
+ * The scope defaults to "debug" but can be changed via setLogScope()
+ * so that different commands (e.g. `loop`, `check`, `bucket`) write
+ * to separate log files.
+ *
+ * DEBUG is a comma-separated list of match expressions. Each expression
+ * can contain `*` as a wildcard (matches any sequence of characters).
+ *
+ * Examples:
+ *   DEBUG=*                      → matches all loggers
+ *   DEBUG=dust.bucket,dust.loop  → exact matches
+ *   DEBUG=dust.bucket.*          → matches dust.bucket.loop, dust.bucket.ws, etc.
+ *   DEBUG=*loop                  → matches dust.cli.commands.loop, dust.bucket.loop, etc.
+ *
+ * Logger names follow the convention `dust.<path>` mirroring the directory
+ * structure under `lib/`. For example, `lib/bucket/repository-loop.ts` uses
+ * the logger name `dust.bucket.repository-loop`.
+ *
+ * No external dependencies.
+ */
+import { type WriteFn } from './sink';
+export { setLogScope } from './sink';
+export type LogFn = (...messages: unknown[]) => void;
+/**
+ * Create a named logger function. The returned function writes to
+ * `log/dust/<scope>.log` when the logger name matches the DEBUG patterns.
+ *
+ * @param name - Logger name, e.g. `dust.bucket.loop`
+ * @param write - Override the default file writer (for testing)
+ */
+export declare function createLogger(name: string, write?: WriteFn): LogFn;
+/**
+ * Check whether a logger name would be enabled under the current DEBUG value.
+ */
+export declare function isEnabled(name: string): boolean;
+/**
+ * Reset internal state (for testing only).
+ */
+export declare function _reset(): void;

package/dist/logging/match.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure pattern-matching logic for debug logger names.
+ *
+ * Parses a DEBUG-style string (comma-separated, `*` wildcards)
+ * and tests logger names against it. No side effects.
+ */
+/**
+ * Parse a DEBUG expression string into an array of RegExp matchers.
+ * Returns an empty array when the input is empty or undefined.
+ */
+export declare function parsePatterns(debug: string | undefined): RegExp[];
+/**
+ * Test whether a logger name matches any of the compiled patterns.
+ */
+export declare function matchesAny(name: string, patterns: RegExp[]): boolean;
+/**
+ * Format a log line with ISO timestamp and logger name.
+ */
+export declare function formatLine(name: string, messages: unknown[]): string;

package/dist/logging/sink.d.ts

@@ -0,0 +1,24 @@
+/**
+ * File-based log sink — the imperative shell for debug logging.
+ *
+ * Lazily creates `<cwd>/log/dust/<scope>.log` and appends lines to it.
+ * The scope defaults to "debug" but can be changed via setLogScope()
+ * so that different commands write to separate log files.
+ */
+export type WriteFn = (line: string) => void;
+/**
+ * Set the log scope, which determines the output filename.
+ * Must be called before any logger writes (i.e. at command startup).
+ *
+ * For example, `setLogScope('loop')` writes to `log/dust/loop.log`.
+ */
+export declare function setLogScope(name: string): void;
+/**
+ * Write a line to the debug log file.
+ * Silently no-ops if the file cannot be opened.
+ */
+export declare const writeToFile: WriteFn;
+/**
+ * Reset sink state (for testing only).
+ */
+export declare function _resetSink(): void;

package/dist/logging.js

@@ -0,0 +1,86 @@
+// lib/logging/match.ts
+function parsePatterns(debug) {
+  if (!debug)
+    return [];
+  const expressions = debug.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return expressions.map((expr) => {
+    const escaped = expr.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = escaped.replace(/\*/g, ".*");
+    return new RegExp(`^${pattern}$`);
+  });
+}
+function matchesAny(name, patterns) {
+  return patterns.some((re) => re.test(name));
+}
+function formatLine(name, messages) {
+  const text = messages.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+  return `${new Date().toISOString()} [${name}] ${text}
+`;
+}
+
+// lib/logging/sink.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var logPath;
+var ready = false;
+var scope = process.env.DEBUG_LOG_SCOPE || "debug";
+function ensureLogFile() {
+  if (ready)
+    return logPath;
+  ready = true;
+  const dir = join(process.cwd(), "log", "dust");
+  logPath = join(dir, `${scope}.log`);
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch {
+    logPath = undefined;
+  }
+  return logPath;
+}
+function setLogScope(name) {
+  scope = name;
+  process.env.DEBUG_LOG_SCOPE = name;
+  logPath = undefined;
+  ready = false;
+}
+var writeToFile = (line) => {
+  const path = ensureLogFile();
+  if (!path)
+    return;
+  try {
+    appendFileSync(path, line);
+  } catch {}
+};
+
+// lib/logging/index.ts
+var patterns = null;
+var initialized = false;
+function init() {
+  if (initialized)
+    return;
+  initialized = true;
+  const parsed = parsePatterns(process.env.DEBUG);
+  patterns = parsed.length > 0 ? parsed : null;
+}
+function createLogger(name, write = writeToFile) {
+  return (...messages) => {
+    init();
+    if (!patterns || !matchesAny(name, patterns))
+      return;
+    write(formatLine(name, messages));
+  };
+}
+function isEnabled(name) {
+  init();
+  return patterns !== null && matchesAny(name, patterns);
+}
+function _reset() {
+  initialized = false;
+  patterns = null;
+}
+export {
+  setLogScope,
+  isEnabled,
+  createLogger,
+  _reset
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {
@@ -14,6 +14,10 @@
       "import": "./dist/workflow-tasks.js",
       "types": "./dist/workflow-tasks.d.ts"
     },
+    "./logging": {
+      "import": "./dist/logging.js",
+      "types": "./dist/logging/index.d.ts"
+    },
     "./istanbul/minimal-reporter": "./lib/istanbul/minimal-reporter.cjs"
   },
   "files": [
@@ -34,7 +38,7 @@
   "author": "joshski",
   "license": "MIT",
   "scripts": {
-    "build": "bun build lib/cli/run.ts --target node --outfile dist/dust.js && printf '%s\\n%s' '#!/usr/bin/env node' \"$(cat dist/dust.js)\" > dist/dust.js && bun build lib/workflow-tasks.ts --target node --outfile dist/workflow-tasks.js && bunx tsc --project tsconfig.build.json",
+    "build": "bun build lib/cli/run.ts --target node --outfile dist/dust.js && printf '%s\\n%s' '#!/usr/bin/env node' \"$(cat dist/dust.js)\" > dist/dust.js && bun build lib/workflow-tasks.ts --target node --outfile dist/workflow-tasks.js && bun build lib/logging/index.ts --target node --outfile dist/logging.js && bunx tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "eval": "bun run ./evals/run.ts"