assistme 0.8.1 → 0.8.2

package/dist/{chunk-QHMIXIWO.js → chunk-A2NR7LCQ.js}

@@ -59,9 +59,28 @@ async function callMcpHandler(action, params = {}, overrideToken) {
 // src/utils/logger.ts
 import chalk from "chalk";
 import { randomUUID } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
 var currentLevel = "info";
 var currentCorrelationId = null;
+var currentConversationId = null;
 var logHook = null;
+var logTransport = null;
+var PKG_VERSION = (() => {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    for (const rel of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join2(__dirname, rel), "utf-8"));
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+})();
 var LEVEL_ORDER = {
   debug: 0,
   info: 1,
@@ -74,9 +93,15 @@ function setLogLevel(level) {
 function setLogHook(hook) {
   logHook = hook;
 }
+function setLogTransport(transport) {
+  logTransport = transport;
+}
 function setCorrelationId(id) {
   currentCorrelationId = id;
 }
+function setLogConversationId(id) {
+  currentConversationId = id;
+}
 function newCorrelationId() {
   const id = randomUUID().slice(0, 8);
   currentCorrelationId = id;
@@ -90,54 +115,87 @@ function timestamp() {
 }
 function prefix() {
   const ts = timestamp();
-  return currentCorrelationId ? `${ts} ${currentCorrelationId}` : ts;
+  const base = `${ts} v${PKG_VERSION}`;
+  return currentCorrelationId ? `${base} ${currentCorrelationId}` : base;
 }
 var log = {
   debug(msg, ...args) {
     if (shouldLog("debug")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", `[DEBUG] ${text}`);
+      if (logTransport) {
+        logTransport("debug", text);
+        return;
+      }
+      logHook?.("stdout", `[DEBUG] ${text}`, currentConversationId);
       console.log(chalk.gray(`[${prefix()}] DEBUG`), msg, ...args);
     }
   },
   info(msg, ...args) {
     if (shouldLog("info")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", text);
+      if (logTransport) {
+        logTransport("info", text);
+        return;
+      }
+      logHook?.("stdout", text, currentConversationId);
       console.log(chalk.blue(`[${prefix()}]`), msg, ...args);
     }
   },
   success(msg, ...args) {
     if (shouldLog("info")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", `\u2713 ${text}`);
+      if (logTransport) {
+        logTransport("success", text);
+        return;
+      }
+      logHook?.("stdout", `\u2713 ${text}`, currentConversationId);
       console.log(chalk.green(`[${prefix()}] \u2713`), msg, ...args);
     }
   },
   warn(msg, ...args) {
     if (shouldLog("warn")) {
       const text = formatArgs(msg, args);
-      logHook?.("stderr", `[WARN] ${text}`);
+      if (logTransport) {
+        logTransport("warn", text);
+        return;
+      }
+      logHook?.("stderr", `[WARN] ${text}`, currentConversationId);
       console.log(chalk.yellow(`[${prefix()}] WARN`), msg, ...args);
     }
   },
   error(msg, ...args) {
     if (shouldLog("error")) {
       const text = formatArgs(msg, args);
-      logHook?.("stderr", `[ERROR] ${text}`);
+      if (logTransport) {
+        logTransport("error", text);
+        return;
+      }
+      logHook?.("stderr", `[ERROR] ${text}`, currentConversationId);
       console.error(chalk.red(`[${prefix()}] ERROR`), msg, ...args);
     }
   },
   agent(msg) {
-    logHook?.("stdout", `\u25B8 ${msg}`);
+    if (logTransport) {
+      logTransport("agent", msg);
+      return;
+    }
+    logHook?.("stdout", `\u25B8 ${msg}`, currentConversationId);
     console.log(chalk.cyan("  \u25B8"), msg);
   },
   tool(name, msg) {
-    logHook?.("stdout", `\u26A1 ${name}: ${msg}`);
+    if (logTransport) {
+      logTransport("tool", msg, name);
+      return;
+    }
+    logHook?.("stdout", `\u26A1 ${name}: ${msg}`, currentConversationId);
     console.log(chalk.magenta(`  \u26A1 ${name}:`), msg);
   },
   result(msg) {
-    logHook?.("stdout", `\u2190 ${msg}`);
+    if (logTransport) {
+      logTransport("result", msg);
+      return;
+    }
+    logHook?.("stdout", `\u2190 ${msg}`, currentConversationId);
     console.log(chalk.green("  \u2190"), msg);
   }
 };
@@ -480,7 +538,9 @@ export {
   callMcpHandler,
   setLogLevel,
   setLogHook,
+  setLogTransport,
   setCorrelationId,
+  setLogConversationId,
   newCorrelationId,
   log,
   MAX_RESPONSE_CONTENT_LENGTH,

package/dist/{chunk-4RHN77BN.js → chunk-IKYXC4RJ.js}

@@ -19,7 +19,7 @@ import {
   readAuthStore,
   safeParse,
   writeAuthStore
-} from "./chunk-QHMIXIWO.js";
+} from "./chunk-A2NR7LCQ.js";
 import {
   getConfig
 } from "./chunk-YYSJHZSO.js";

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   setSessionBusy,
   toggleScheduledTask,
   updateHeartbeat
-} from "./chunk-4RHN77BN.js";
+} from "./chunk-IKYXC4RJ.js";
 import {
   HEARTBEAT_INTERVAL_MS,
   HEARTBEAT_LOG_MAX_ENTRIES,
@@ -36,9 +36,10 @@ import {
   callMcpHandler,
   errorMessage,
   log,
+  setLogConversationId,
   setLogHook,
   setLogLevel
-} from "./chunk-QHMIXIWO.js";
+} from "./chunk-A2NR7LCQ.js";
 import {
   clearConfig,
   getConfig,
@@ -884,8 +885,6 @@ var WorkerManager = class {
   workers = /* @__PURE__ */ new Map();
   /** Maps conversation ID → worker ID for fast lookup. */
   conversationWorkers = /* @__PURE__ */ new Map();
-  /** The singleton job-analyzer worker ID (if running). */
-  jobAnalyzerWorkerId = null;
   userId;
   sessionId;
   running = true;
@@ -941,17 +940,6 @@ var WorkerManager = class {
     }
     await completionPromise;
   }
-  /**
-   * Ensure the job-analyzer worker is running.
-   * The job-analyzer runs its own polling loop — no need to send tasks.
-   */
-  async ensureJobAnalyzer() {
-    if (this.jobAnalyzerWorkerId && this.workers.has(this.jobAnalyzerWorkerId)) {
-      return;
-    }
-    const worker = await this.spawnWorker("job-analyzer");
-    this.jobAnalyzerWorkerId = worker.id;
-  }
   /**
    * Graceful shutdown: stop all workers.
    */
@@ -968,7 +956,6 @@ var WorkerManager = class {
     this.taskCompletions.clear();
     this.workers.clear();
     this.conversationWorkers.clear();
-    this.jobAnalyzerWorkerId = null;
   }
   /**
    * Get info about all active workers.
@@ -1075,11 +1062,6 @@ var WorkerManager = class {
         }
         break;
       }
-      case "job_analyzed":
-        log.info(
-          `[worker:${worker.id}] Job "${message.jobName}" analyzed, skills: ${message.skillsCreated.join(", ") || "(none)"}`
-        );
-        break;
       case "idle":
         this.workerBecameIdle(worker);
         break;
@@ -1098,6 +1080,38 @@ var WorkerManager = class {
             log.debug(`[worker:${worker.id}] ${message.message}`);
         }
         break;
+      case "log_forward": {
+        const convId = worker.conversationId || null;
+        setLogConversationId(convId);
+        const convTag = convId ? `[conv:${convId.slice(0, 8)}]` : `[worker:${worker.id}]`;
+        switch (message.method) {
+          case "agent":
+            log.agent(`${convTag} ${message.message}`);
+            break;
+          case "tool":
+            log.tool(message.extra || "unknown", `${convTag} ${message.message}`);
+            break;
+          case "result":
+            log.result(`${convTag} ${message.message}`);
+            break;
+          case "success":
+            log.success(`${convTag} ${message.message}`);
+            break;
+          case "error":
+            log.error(`${convTag} ${message.message}`);
+            break;
+          case "warn":
+            log.warn(`${convTag} ${message.message}`);
+            break;
+          case "info":
+            log.info(`${convTag} ${message.message}`);
+            break;
+          default:
+            log.debug(`${convTag} ${message.message}`);
+        }
+        setLogConversationId(null);
+        break;
+      }
       case "error":
         log.error(`[worker:${worker.id}] Error: ${message.error}`);
         break;
@@ -1165,9 +1179,6 @@ var WorkerManager = class {
     }
     worker.pendingTaskIds.clear();
     this.workers.delete(worker.id);
-    if (this.jobAnalyzerWorkerId === worker.id) {
-      this.jobAnalyzerWorkerId = null;
-    }
   }
   async stopWorker(worker, timeoutMs) {
     if (worker.status === "stopped") return;
@@ -1214,6 +1225,7 @@ var WorkerManager = class {
 var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
 var DEFAULT_POLL_INTERVAL = 2e3;
 var MAX_POLL_INTERVAL = 3e4;
+var JOB_ANALYSIS_POLL_INTERVAL = 3e4;
 var Orchestrator = class {
   session = null;
   heartbeatTimer = null;
@@ -1227,6 +1239,9 @@ var Orchestrator = class {
   consecutivePollFailures = 0;
   heartbeatInterval;
   basePollInterval;
+  jobAnalysisTimer = null;
+  /** Track jobs currently being analyzed to avoid duplicate tasks. */
+  analyzingJobIds = /* @__PURE__ */ new Set();
   constructor() {
     this.scheduler = new Scheduler();
     this.heartbeatEngine = new HeartbeatEngine();
@@ -1261,9 +1276,7 @@ var Orchestrator = class {
     this.heartbeatEngine.start(async (prompt) => {
       await this.executeHeartbeatAction(prompt);
     });
-    this.workerManager.ensureJobAnalyzer().catch((err) => {
-      log.debug(`Job analyzer startup deferred: ${err}`);
-    });
+    this.startJobAnalysisPoll();
     this.cleanupStaleSessions().catch(() => {
     });
     return this.session;
@@ -1369,6 +1382,94 @@ var Orchestrator = class {
       }
     }
   }
+  // ── Job Analysis (as regular tasks) ─────────────────────────────
+  startJobAnalysisPoll() {
+    setTimeout(() => this.pollForUnanalyzedJobs(), 5e3);
+    this.jobAnalysisTimer = setInterval(() => {
+      this.pollForUnanalyzedJobs();
+    }, JOB_ANALYSIS_POLL_INTERVAL);
+  }
+  async pollForUnanalyzedJobs() {
+    if (!this.running || !this.session || !this.conversationId) return;
+    try {
+      const jobs = await callMcpHandler(
+        "job.list_unanalyzed"
+      );
+      if (!jobs || jobs.length === 0) return;
+      for (const job of jobs) {
+        if (this.analyzingJobIds.has(job.id)) continue;
+        this.analyzingJobIds.add(job.id);
+        log.info(`Dispatching job analysis task for "${job.name}"`);
+        const runner = new JobRunner();
+        const jobInfo = await runner.loadJob(job.name);
+        if (!jobInfo) {
+          log.debug(`Job "${job.name}" not found, skipping analysis`);
+          await this.markJobAnalyzed(job.id);
+          this.analyzingJobIds.delete(job.id);
+          continue;
+        }
+        const prompt = this.buildJobAnalysisPrompt(jobInfo);
+        await this.markJobAnalyzed(job.id);
+        this.dispatchTask(`[JobAnalysis: ${job.name}] ${prompt}`).then(() => {
+          log.info(`Job "${job.name}" analysis task dispatched`);
+        }).catch((err) => {
+          log.debug(`Job analysis dispatch failed for "${job.name}": ${err}`);
+        }).finally(() => {
+          this.analyzingJobIds.delete(job.id);
+        });
+      }
+    } catch (err) {
+      log.debug(`Job analysis poll error: ${err}`);
+    }
+  }
+  buildJobAnalysisPrompt(job) {
+    let prompt = `Analyze this job definition and determine what skills are needed to execute it effectively.
+
+`;
+    prompt += `## Job Definition
+`;
+    prompt += `**Name:** ${job.jobName}
+`;
+    prompt += `**Description:** ${job.jobDescription}
+
+`;
+    if (job.skills.length > 0) {
+      prompt += `**Current Skills:**
+`;
+      for (const skill of job.skills) {
+        const emoji = skill.skillEmoji ? `${skill.skillEmoji} ` : "";
+        prompt += `- ${emoji}${skill.skillName}: ${skill.skillDescription}
+`;
+      }
+      prompt += `
+`;
+    }
+    prompt += `## Instructions
+`;
+    prompt += `For each capability the job needs:
+`;
+    prompt += `1. Check if an existing skill covers it (use \`skill_search\` to check)
+`;
+    prompt += `2. If no existing skill covers it, create a new one using \`skill_create\`
+`;
+    prompt += `3. If an existing skill needs improvement, update it using \`skill_improve\`
+`;
+    prompt += `4. Link all relevant skills to the job using \`skill_link_job\`
+
+`;
+    prompt += `Be practical \u2014 only create skills that would genuinely help automate this job.
+`;
+    prompt += `When done, summarize what skills were created, updated, or already existed.
+`;
+    return prompt;
+  }
+  async markJobAnalyzed(jobId) {
+    try {
+      await callMcpHandler("job.mark_analyzed", { job_id: jobId });
+    } catch (err) {
+      log.debug(`Failed to mark job analyzed: ${err}`);
+    }
+  }
   // ── Scheduled & Heartbeat Tasks ─────────────────────────────────
   async executeScheduledTask(scheduledTask) {
     if (!this.session || !this.userId || !this.conversationId) return;
@@ -1446,6 +1547,10 @@ var Orchestrator = class {
       clearTimeout(this.pollTimer);
       this.pollTimer = null;
     }
+    if (this.jobAnalysisTimer) {
+      clearInterval(this.jobAnalysisTimer);
+      this.jobAnalysisTimer = null;
+    }
     if (this.workerManager) {
       await this.workerManager.shutdown(timeoutMs);
     }
@@ -1496,9 +1601,9 @@ var SessionLogEmitter = class {
   flushTimer = null;
   flushing = false;
   /** Queue a log entry for batch insertion */
-  push(logType, message) {
+  push(logType, message, conversationId) {
     this.sequence++;
-    this.buffer.push({ log_type: logType, message, seq: this.sequence });
+    this.buffer.push({ log_type: logType, message, seq: this.sequence, conversation_id: conversationId || null });
     if (this.buffer.length >= MAX_BATCH_SIZE) {
       this.flush();
     }
@@ -1570,17 +1675,15 @@ function registerMonitorCommands(program2) {
       }
       const status = sharedHeartbeat.getStatus();
       console.log(chalk4.bold("\nHeartbeat Status:"));
+      console.log(`  Enabled:    ${status.enabled ? chalk4.green("yes") : chalk4.red("no")}`);
       console.log(
-        `  Enabled:    ${status.enabled ? chalk4.green("yes") : chalk4.red("no")}`
+        `  Interval:   ${status.intervalMs / 1e3}s (${status.intervalMs / 6e4} min)`
       );
-      console.log(`  Interval:   ${status.intervalMs / 1e3}s (${status.intervalMs / 6e4} min)`);
       console.log(`  Cycles:     ${status.cycleCount}`);
       console.log(
         `  Checklist:  ${status.hasChecklist ? chalk4.green("found") : chalk4.yellow("no HEARTBEAT.md")}`
       );
-      console.log(
-        `  Executing:  ${status.executing ? chalk4.yellow("running now") : "idle"}`
-      );
+      console.log(`  Executing:  ${status.executing ? chalk4.yellow("running now") : "idle"}`);
       console.log();
     } catch (err) {
       log.error(`${err instanceof Error ? err.message : err}`);
@@ -1765,11 +1868,11 @@ async function runAgent(opts) {
     const session = await orchestrator.start(userId);
     setSharedMonitor(orchestrator.getHeartbeatEngine());
     logEmitter = new SessionLogEmitter(session.id);
-    setLogHook((logType, message) => {
-      logEmitter?.push(logType, message);
+    setLogHook((logType, message, conversationId) => {
+      logEmitter?.push(logType, message, conversationId);
     });
     log.info("Listening for tasks (chat + jobs) from web UI...");
-    log.info(`Workers: conversation (per-conversation), job-analyzer (singleton)`);
+    log.info(`Workers: conversation (per-conversation)`);
     log.info("Press Ctrl+C to stop.\n");
     const rl = createInterface2({
       input: process.stdin,
@@ -2186,7 +2289,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-YM2NBIL3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-PECVS424.js");
       const runner = new JobRunner2();
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -2210,7 +2313,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-YM2NBIL3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-PECVS424.js");
       const runner = new JobRunner2();
       const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
       if (runs.length === 0) {
@@ -2249,7 +2352,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`));
         process.exit(1);
       }
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-YM2NBIL3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-PECVS424.js");
       const runner = new JobRunner2();
       const job = await runner.loadJob(name);
       if (!job) {

package/dist/{job-runner-YM2NBIL3.js → job-runner-PECVS424.js}

@@ -1,6 +1,6 @@
 import {
   JobRunner
-} from "./chunk-QHMIXIWO.js";
+} from "./chunk-A2NR7LCQ.js";
 import "./chunk-YYSJHZSO.js";
 export {
   JobRunner