assistme 0.8.8 → 0.8.9

package/dist/index.js

@@ -1290,6 +1290,64 @@ var SessionHeartbeat = class {
   }
 };
 
+// src/agent/title-generator.ts
+import {
+  query as query3
+} from "@anthropic-ai/claude-agent-sdk";
+var TITLE_OUTPUT_FORMAT = {
+  type: "json_schema",
+  schema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "A very short title (max 6 words) for the task conversation"
+      }
+    },
+    required: ["title"],
+    additionalProperties: false
+  }
+};
+async function generateTitle(prompt) {
+  if (!prompt.trim()) return "Untitled";
+  const systemPrompt = "Generate a very short title (max 6 words) for a task conversation based on the user's prompt. Return ONLY the title, no quotes, no punctuation at the end. If the prompt is in Chinese, generate a Chinese title.";
+  let title = "Untitled";
+  for await (const message of query3({
+    prompt,
+    options: {
+      model: "claude-haiku-4-5-20251001",
+      systemPrompt,
+      allowedTools: [],
+      effort: "low",
+      outputFormat: TITLE_OUTPUT_FORMAT
+    }
+  })) {
+    if (message.type === "result") {
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        const successMsg = resultMsg;
+        const output = successMsg.structured_output;
+        if (output?.title) {
+          title = String(output.title).trim().slice(0, 100);
+        }
+      }
+    }
+  }
+  return title;
+}
+async function generateAndSaveTitle(conversationId, prompt) {
+  try {
+    const title = await generateTitle(prompt);
+    await callMcpHandler("conversation.update_title", {
+      conversation_id: conversationId,
+      title
+    });
+    log.info(`Generated title: "${title}"`);
+  } catch (err) {
+    log.debug(`Title generation failed (non-critical): ${err}`);
+  }
+}
+
 // src/orchestrator.ts
 var Orchestrator = class {
   session = null;
@@ -1303,10 +1361,12 @@ var Orchestrator = class {
   workerManager = null;
   userId = null;
   conversationId = null;
+  titleGenerated = false;
   // ── Lifecycle ───────────────────────────────────────────────────
   async start(userId) {
     const config = getConfig();
     this.userId = userId;
+    this.titleGenerated = false;
     this.session = await createSession(config.sessionName, config.workspacePath, "0.1.0");
     this.conversationId = await getOrCreateCliConversation();
     this.workerManager = new WorkerManager(userId, this.session.id);
@@ -1377,6 +1437,12 @@ var Orchestrator = class {
     }
     const task = await createTask(this.conversationId, this.session.id, prompt);
     await claimTask(task.id);
+    if (!this.titleGenerated) {
+      this.titleGenerated = true;
+      generateAndSaveTitle(this.conversationId, prompt).catch(
+        (err) => log.debug(`Title generation failed: ${err}`)
+      );
+    }
     await this.workerManager.dispatchTask(task);
   }
   async dispatchAndWait(prompt) {
@@ -1979,17 +2045,17 @@ Memories (${memories.length}):`));
       process.exit(1);
     }
   });
-  memoryCmd.command("search <query>").description("Search memories").action(async (query3) => {
+  memoryCmd.command("search <query>").description("Search memories").action(async (query4) => {
     try {
       await getCurrentUserId();
       const mm = new MemoryManager();
-      const results = await mm.search(query3);
+      const results = await mm.search(query4);
       if (results.length === 0) {
-        console.log(chalk8.yellow(`No memories matching "${query3}"`));
+        console.log(chalk8.yellow(`No memories matching "${query4}"`));
         return;
       }
       console.log(chalk8.bold(`
-Search results for "${query3}":`));
+Search results for "${query4}":`));
       for (const m of results) {
         console.log(`  [${m.category}] ${m.content}`);
       }
@@ -2055,18 +2121,18 @@ function registerSkillCommands(program2) {
     );
     console.log();
   });
-  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query3) => {
+  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query4) => {
     const spinner = ora4("Searching skills...").start();
     const sm = await getAuthenticatedSkillManager();
     try {
-      const results = await sm.searchDb(query3);
+      const results = await sm.searchDb(query4);
       spinner.stop();
       if (results.length === 0) {
-        console.log(chalk9.yellow(`No skills found for "${query3}"`));
+        console.log(chalk9.yellow(`No skills found for "${query4}"`));
         return;
       }
       console.log(chalk9.bold(`
-Skills matching "${query3}":`));
+Skills matching "${query4}":`));
       for (const r of results) {
         const emoji = r.emoji ? `${r.emoji} ` : "";
         console.log(`  ${emoji}${chalk9.cyan(r.name)} [${r.source}]`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "AssistMe CLI Agent - AI-powered agentic assistant for code, browser, and automation",
   "type": "module",
   "main": "dist/index.js",

package/src/agent/title-generator.ts

@@ -0,0 +1,82 @@
+import {
+  query,
+  type SDKResultMessage,
+  type SDKResultSuccess,
+  type OutputFormat,
+} from "@anthropic-ai/claude-agent-sdk";
+import { callMcpHandler } from "../db/api-client.js";
+import { log } from "../utils/logger.js";
+
+/**
+ * Structured output schema for title generation.
+ */
+const TITLE_OUTPUT_FORMAT: OutputFormat = {
+  type: "json_schema",
+  schema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "A very short title (max 6 words) for the task conversation",
+      },
+    },
+    required: ["title"],
+    additionalProperties: false,
+  },
+};
+
+/**
+ * Generate a short conversation title from the user's prompt.
+ * Uses the Claude Agent SDK query() with structured output.
+ */
+export async function generateTitle(prompt: string): Promise<string> {
+  if (!prompt.trim()) return "Untitled";
+
+  const systemPrompt =
+    "Generate a very short title (max 6 words) for a task conversation based on the user's prompt. " +
+    "Return ONLY the title, no quotes, no punctuation at the end. " +
+    "If the prompt is in Chinese, generate a Chinese title.";
+
+  let title = "Untitled";
+
+  for await (const message of query({
+    prompt,
+    options: {
+      model: "claude-haiku-4-5-20251001",
+      systemPrompt,
+      allowedTools: [],
+      effort: "low",
+      outputFormat: TITLE_OUTPUT_FORMAT,
+    },
+  })) {
+    if (message.type === "result") {
+      const resultMsg = message as SDKResultMessage;
+      if (resultMsg.subtype === "success") {
+        const successMsg = resultMsg as SDKResultSuccess;
+        const output = successMsg.structured_output as { title?: string } | undefined;
+        if (output?.title) {
+          title = String(output.title).trim().slice(0, 100);
+        }
+      }
+    }
+  }
+
+  return title;
+}
+
+/**
+ * Generate and save a title for a conversation.
+ * Fails silently — title generation is best-effort.
+ */
+export async function generateAndSaveTitle(conversationId: string, prompt: string): Promise<void> {
+  try {
+    const title = await generateTitle(prompt);
+    await callMcpHandler("conversation.update_title", {
+      conversation_id: conversationId,
+      title,
+    });
+    log.info(`Generated title: "${title}"`);
+  } catch (err) {
+    log.debug(`Title generation failed (non-critical): ${err}`);
+  }
+}

package/src/orchestrator.ts

@@ -32,6 +32,7 @@ import { WorkerManager } from "./workers/manager.js";
 import { JobAnalysisPoller } from "./agent/job-analysis-poller.js";
 import { TaskPoller } from "./agent/task-poller.js";
 import { SessionHeartbeat } from "./agent/session-heartbeat.js";
+import { generateAndSaveTitle } from "./agent/title-generator.js";
 
 export class Orchestrator {
   private session: AgentSession | null = null;
@@ -47,12 +48,14 @@ export class Orchestrator {
 
   private userId: string | null = null;
   private conversationId: string | null = null;
+  private titleGenerated = false;
 
   // ── Lifecycle ───────────────────────────────────────────────────
 
   async start(userId: string): Promise<AgentSession> {
     const config = getConfig();
     this.userId = userId;
+    this.titleGenerated = false;
 
     this.session = await createSession(config.sessionName, config.workspacePath, "0.1.0");
     this.conversationId = await getOrCreateCliConversation();
@@ -141,6 +144,15 @@ export class Orchestrator {
 
     const task = await createTask(this.conversationId, this.session.id, prompt);
     await claimTask(task.id);
+
+    // Generate title on first task (fire-and-forget, non-blocking)
+    if (!this.titleGenerated) {
+      this.titleGenerated = true;
+      generateAndSaveTitle(this.conversationId, prompt).catch((err) =>
+        log.debug(`Title generation failed: ${err}`)
+      );
+    }
+
     await this.workerManager!.dispatchTask(task);
   }
 

package/tests/agent/title-generator.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── Mocks ────────────────────────────────────────────────────────
+
+let mockQueryCalls: unknown[] = [];
+const mockQueryMessages: unknown[] = [];
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: vi.fn((params: unknown) => {
+    mockQueryCalls.push(params);
+    return {
+      [Symbol.asyncIterator]: async function* () {
+        for (const msg of mockQueryMessages) {
+          yield msg;
+        }
+      },
+    };
+  }),
+}));
+
+const mockCallMcpHandler = vi.fn().mockResolvedValue(null);
+vi.mock("../../src/db/api-client.js", () => ({
+  callMcpHandler: (...args: unknown[]) => mockCallMcpHandler(...args),
+}));
+
+vi.mock("../../src/utils/logger.js", () => ({
+  log: {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+// ── Import after mocks ──────────────────────────────────────────
+
+import { generateTitle, generateAndSaveTitle } from "../../src/agent/title-generator.js";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe("title-generator", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockQueryCalls = [];
+    mockQueryMessages.length = 0;
+  });
+
+  describe("generateTitle", () => {
+    it("returns Untitled for empty prompt", async () => {
+      const title = await generateTitle("");
+      expect(title).toBe("Untitled");
+      expect(query).not.toHaveBeenCalled();
+    });
+
+    it("returns Untitled for whitespace-only prompt", async () => {
+      const title = await generateTitle("   ");
+      expect(title).toBe("Untitled");
+      expect(query).not.toHaveBeenCalled();
+    });
+
+    it("passes correct SDK query options", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: "Fix Login Bug" },
+      });
+
+      await generateTitle("The login button is broken");
+
+      expect(mockQueryCalls).toHaveLength(1);
+      const call = mockQueryCalls[0] as { prompt: string; options: Record<string, unknown> };
+      expect(call.prompt).toBe("The login button is broken");
+      expect(call.options.model).toBe("claude-haiku-4-5-20251001");
+      expect(call.options.allowedTools).toEqual([]);
+      expect(call.options.effort).toBe("low");
+      expect(call.options.outputFormat).toBeDefined();
+    });
+
+    it("parses valid structured output title", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: "Fix Login Bug" },
+      });
+
+      const title = await generateTitle("The login button is broken");
+      expect(title).toBe("Fix Login Bug");
+    });
+
+    it("returns Untitled when structured_output is missing title field", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: {},
+      });
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toBe("Untitled");
+    });
+
+    it("returns Untitled when structured_output is undefined", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: undefined,
+      });
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toBe("Untitled");
+    });
+
+    it("truncates title longer than 100 characters", async () => {
+      const longTitle = "A".repeat(150);
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: longTitle },
+      });
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toHaveLength(100);
+      expect(title).toBe("A".repeat(100));
+    });
+
+    it("trims whitespace from title", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: "  Fix Bug  " },
+      });
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toBe("Fix Bug");
+    });
+
+    it("returns Untitled on SDK error (non-success result)", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "error",
+      });
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toBe("Untitled");
+    });
+
+    it("ignores non-result messages", async () => {
+      mockQueryMessages.push(
+        { type: "assistant", content: [{ type: "text", text: "hello" }] },
+        {
+          type: "result",
+          subtype: "success",
+          structured_output: { title: "Real Title" },
+        }
+      );
+
+      const title = await generateTitle("Some prompt");
+      expect(title).toBe("Real Title");
+    });
+  });
+
+  describe("generateAndSaveTitle", () => {
+    it("generates title and saves via MCP handler", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: "Deploy Dashboard" },
+      });
+
+      await generateAndSaveTitle("conv-123", "Deploy the dashboard");
+
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("conversation.update_title", {
+        conversation_id: "conv-123",
+        title: "Deploy Dashboard",
+      });
+    });
+
+    it("does not throw on SDK failure (graceful degradation)", async () => {
+      (query as ReturnType<typeof vi.fn>).mockImplementationOnce(() => {
+        throw new Error("SDK unavailable");
+      });
+
+      await expect(generateAndSaveTitle("conv-123", "test")).resolves.toBeUndefined();
+    });
+
+    it("does not throw on MCP handler failure", async () => {
+      mockQueryMessages.push({
+        type: "result",
+        subtype: "success",
+        structured_output: { title: "Some Title" },
+      });
+      mockCallMcpHandler.mockRejectedValueOnce(new Error("MCP failure"));
+
+      await expect(generateAndSaveTitle("conv-123", "test")).resolves.toBeUndefined();
+    });
+  });
+});