@hienlh/ppm 0.9.33 → 0.9.35

package/src/services/db.service.ts

@@ -969,23 +969,23 @@ export function deleteExtensionStorage(extId: string): void {
 }
 
 // ---------------------------------------------------------------------------
-// ClawBot session helpers
+// PPMBot session helpers
 // ---------------------------------------------------------------------------
 
-import type { ClawBotSessionRow, ClawBotMemoryRow, ClawBotPairedChat } from "../types/clawbot.ts";
+import type { PPMBotSessionRow, PPMBotMemoryRow, PPMBotPairedChat } from "../types/ppmbot.ts";
 
-export function getActiveClawBotSession(
+export function getActivePPMBotSession(
   telegramChatId: string,
   projectName: string,
-): ClawBotSessionRow | null {
+): PPMBotSessionRow | null {
   return getDb().query(
     `SELECT * FROM clawbot_sessions
      WHERE telegram_chat_id = ? AND project_name = ? AND is_active = 1
      ORDER BY last_message_at DESC LIMIT 1`,
-  ).get(telegramChatId, projectName) as ClawBotSessionRow | null;
+  ).get(telegramChatId, projectName) as PPMBotSessionRow | null;
 }
 
-export function createClawBotSession(
+export function createPPMBotSession(
   telegramChatId: string,
   sessionId: string,
   providerId: string,
@@ -999,34 +999,34 @@ export function createClawBotSession(
   ).run(telegramChatId, sessionId, providerId, projectName, projectPath);
 }
 
-export function deactivateClawBotSession(sessionId: string): void {
+export function deactivatePPMBotSession(sessionId: string): void {
   getDb().query(
     "UPDATE clawbot_sessions SET is_active = 0 WHERE session_id = ?",
   ).run(sessionId);
 }
 
-export function touchClawBotSession(sessionId: string): void {
+export function touchPPMBotSession(sessionId: string): void {
   getDb().query(
     "UPDATE clawbot_sessions SET last_message_at = unixepoch() WHERE session_id = ?",
   ).run(sessionId);
 }
 
-export function getRecentClawBotSessions(
+export function getRecentPPMBotSessions(
   telegramChatId: string,
   limit = 10,
-): ClawBotSessionRow[] {
+): PPMBotSessionRow[] {
   return getDb().query(
     `SELECT * FROM clawbot_sessions
      WHERE telegram_chat_id = ?
      ORDER BY last_message_at DESC LIMIT ?`,
-  ).all(telegramChatId, limit) as ClawBotSessionRow[];
+  ).all(telegramChatId, limit) as PPMBotSessionRow[];
 }
 
 // ---------------------------------------------------------------------------
-// ClawBot memory helpers
+// PPMBot memory helpers
 // ---------------------------------------------------------------------------
 
-export function insertClawBotMemory(
+export function insertPPMBotMemory(
   project: string,
   content: string,
   category: string,
@@ -1040,11 +1040,11 @@ export function insertClawBotMemory(
   return Number(result.lastInsertRowid);
 }
 
-export function searchClawBotMemories(
+export function searchPPMBotMemories(
   project: string,
   query: string,
   limit = 20,
-): Array<ClawBotMemoryRow & { rank: number }> {
+): Array<PPMBotMemoryRow & { rank: number }> {
   return getDb().query(
     `SELECT m.*, fts.rank
      FROM clawbot_memories m
@@ -1054,23 +1054,23 @@ export function searchClawBotMemories(
        AND m.superseded_by IS NULL
      ORDER BY fts.rank
      LIMIT ?`,
-  ).all(query, project, limit) as Array<ClawBotMemoryRow & { rank: number }>;
+  ).all(query, project, limit) as Array<PPMBotMemoryRow & { rank: number }>;
 }
 
-export function getClawBotMemories(
+export function getPPMBotMemories(
   project: string,
   limit = 20,
-): ClawBotMemoryRow[] {
+): PPMBotMemoryRow[] {
   return getDb().query(
     `SELECT * FROM clawbot_memories
      WHERE project IN (?, '_global')
        AND superseded_by IS NULL
      ORDER BY importance DESC, updated_at DESC
      LIMIT ?`,
-  ).all(project, limit) as ClawBotMemoryRow[];
+  ).all(project, limit) as PPMBotMemoryRow[];
 }
 
-export function supersedeClawBotMemory(
+export function supersedePPMBotMemory(
   oldId: number,
   newId: number,
 ): void {
@@ -1079,7 +1079,7 @@ export function supersedeClawBotMemory(
   ).run(newId, oldId);
 }
 
-export function deleteClawBotMemoriesByTopic(
+export function deletePPMBotMemoriesByTopic(
   project: string,
   topic: string,
 ): number {
@@ -1097,7 +1097,7 @@ export function deleteClawBotMemoriesByTopic(
   return matches.length;
 }
 
-export function decayClawBotMemories(): void {
+export function decayPPMBotMemories(): void {
   getDb().query(
     `UPDATE clawbot_memories
      SET importance = importance * 0.95,
@@ -1112,7 +1112,7 @@ export function decayClawBotMemories(): void {
 }
 
 // ---------------------------------------------------------------------------
-// ClawBot pairing helpers
+// PPMBot pairing helpers
 // ---------------------------------------------------------------------------
 
 export function createPairingRequest(
@@ -1147,22 +1147,22 @@ export function revokePairing(chatId: string): void {
   ).run(chatId);
 }
 
-export function getPairingByCode(code: string): ClawBotPairedChat | null {
+export function getPairingByCode(code: string): PPMBotPairedChat | null {
   return getDb().query(
     "SELECT * FROM clawbot_paired_chats WHERE pairing_code = ? AND status = 'pending'",
-  ).get(code) as ClawBotPairedChat | null;
+  ).get(code) as PPMBotPairedChat | null;
 }
 
-export function getPairingByChatId(chatId: string): ClawBotPairedChat | null {
+export function getPairingByChatId(chatId: string): PPMBotPairedChat | null {
   return getDb().query(
     "SELECT * FROM clawbot_paired_chats WHERE telegram_chat_id = ?",
-  ).get(chatId) as ClawBotPairedChat | null;
+  ).get(chatId) as PPMBotPairedChat | null;
 }
 
-export function listPairedChats(): ClawBotPairedChat[] {
+export function listPairedChats(): PPMBotPairedChat[] {
   return getDb().query(
     "SELECT * FROM clawbot_paired_chats WHERE status != 'revoked' ORDER BY created_at DESC",
-  ).all() as ClawBotPairedChat[];
+  ).all() as PPMBotPairedChat[];
 }
 
 export function isPairedChat(chatId: string): boolean {

package/src/services/{clawbot/clawbot-memory.ts → ppmbot/ppmbot-memory.ts}

@@ -1,17 +1,17 @@
 import {
-  insertClawBotMemory,
-  searchClawBotMemories,
-  getClawBotMemories,
-  supersedeClawBotMemory,
-  deleteClawBotMemoriesByTopic,
-  decayClawBotMemories,
+  insertPPMBotMemory,
+  searchPPMBotMemories,
+  getPPMBotMemories,
+  supersedePPMBotMemory,
+  deletePPMBotMemoriesByTopic,
+  decayPPMBotMemories,
   getDb,
 } from "../db.service.ts";
 import { configService } from "../config.service.ts";
 import type {
-  ClawBotMemoryCategory,
+  PPMBotMemoryCategory,
   MemoryRecallResult,
-} from "../../types/clawbot.ts";
+} from "../../types/ppmbot.ts";
 import type { ProjectConfig } from "../../types/config.ts";
 
 /** Max memories per project before pruning */
@@ -20,11 +20,11 @@ const MAX_MEMORIES_PER_PROJECT = 500;
 /** Fact extracted from AI response */
 interface ExtractedFact {
   content: string;
-  category: ClawBotMemoryCategory;
+  category: PPMBotMemoryCategory;
   importance?: number;
 }
 
-export class ClawBotMemory {
+export class PPMBotMemory {
   /**
    * Recall relevant memories for a project.
    * If query provided, use FTS5 search. Otherwise return top by importance.
@@ -34,7 +34,7 @@ export class ClawBotMemory {
       const sanitized = this.sanitizeFtsQuery(query);
       if (sanitized) {
         try {
-          const results = searchClawBotMemories(project, sanitized, limit);
+          const results = searchPPMBotMemories(project, sanitized, limit);
           return results.map((r) => ({
             id: r.id,
             content: r.content,
@@ -49,7 +49,7 @@ export class ClawBotMemory {
       }
     }
 
-    const rows = getClawBotMemories(project, limit);
+    const rows = getPPMBotMemories(project, limit);
     return rows.map((r) => ({
       id: r.id,
       content: r.content,
@@ -94,7 +94,7 @@ export class ClawBotMemory {
 
       const existingId = this.findSimilar(project, fact.content);
 
-      const newId = insertClawBotMemory(
+      const newId = insertPPMBotMemory(
         project,
         fact.content.trim(),
         fact.category || "fact",
@@ -103,7 +103,7 @@ export class ClawBotMemory {
       );
 
       if (existingId) {
-        supersedeClawBotMemory(existingId, newId);
+        supersedePPMBotMemory(existingId, newId);
       }
 
       inserted++;
@@ -117,13 +117,13 @@ export class ClawBotMemory {
   saveOne(
     project: string,
     content: string,
-    category: ClawBotMemoryCategory = "fact",
+    category: PPMBotMemoryCategory = "fact",
     sessionId?: string,
   ): number {
     const existingId = this.findSimilar(project, content);
-    const newId = insertClawBotMemory(project, content.trim(), category, 1.0, sessionId);
+    const newId = insertPPMBotMemory(project, content.trim(), category, 1.0, sessionId);
     if (existingId) {
-      supersedeClawBotMemory(existingId, newId);
+      supersedePPMBotMemory(existingId, newId);
     }
     return newId;
   }
@@ -132,12 +132,12 @@ export class ClawBotMemory {
   forget(project: string, topic: string): number {
     const sanitized = this.sanitizeFtsQuery(topic);
     if (!sanitized) return 0;
-    return deleteClawBotMemoriesByTopic(project, sanitized);
+    return deletePPMBotMemoriesByTopic(project, sanitized);
   }
 
   /** Get summary of all active memories for a project */
   getSummary(project: string, limit = 30): MemoryRecallResult[] {
-    const rows = getClawBotMemories(project, limit);
+    const rows = getPPMBotMemories(project, limit);
     return rows.map((r) => ({
       id: r.id,
       content: r.content,
@@ -214,7 +214,7 @@ If nothing worth remembering, return []`;
         }))
         .filter((f) => f.content.length > 0);
     } catch {
-      console.warn("[clawbot-memory] Failed to parse extraction response");
+      console.warn("[ppmbot-memory] Failed to parse extraction response");
       return [];
     }
   }
@@ -225,7 +225,7 @@ If nothing worth remembering, return []`;
    */
   extractiveMemoryFallback(conversationText: string): ExtractedFact[] {
     const facts: ExtractedFact[] = [];
-    const patterns: Array<{ re: RegExp; category: ClawBotMemoryCategory }> = [
+    const patterns: Array<{ re: RegExp; category: PPMBotMemoryCategory }> = [
       { re: /(?:decided|chose|went with|picked|selected)\s+(.{10,100})/gi, category: "decision" },
       { re: /(?:prefer|always use|like to|rather)\s+(.{10,80})/gi, category: "preference" },
       { re: /(?:uses?|built with|stack is|powered by|database is)\s+(.{5,80})/gi, category: "architecture" },
@@ -246,9 +246,9 @@ If nothing worth remembering, return []`;
   /** Run importance decay on old memories */
   runDecay(): void {
     try {
-      decayClawBotMemories();
+      decayPPMBotMemories();
     } catch (err) {
-      console.error("[clawbot-memory] Decay error:", (err as Error).message);
+      console.error("[ppmbot-memory] Decay error:", (err as Error).message);
     }
   }
 
@@ -272,7 +272,7 @@ If nothing worth remembering, return []`;
          )`,
       ).run(project, excess);
     } catch (err) {
-      console.error("[clawbot-memory] Prune error:", (err as Error).message);
+      console.error("[ppmbot-memory] Prune error:", (err as Error).message);
     }
   }
 
@@ -301,7 +301,7 @@ If nothing worth remembering, return []`;
     if (!query) return null;
 
     try {
-      const results = searchClawBotMemories(project, query, 3);
+      const results = searchPPMBotMemories(project, query, 3);
       if (results.length > 0 && results[0]!.rank < -5) {
         return results[0]!.id;
       }
@@ -322,12 +322,12 @@ If nothing worth remembering, return []`;
   }
 
   /** Validate category string against known values */
-  private validateCategory(cat: string): ClawBotMemoryCategory {
-    const valid: ClawBotMemoryCategory[] = [
+  private validateCategory(cat: string): PPMBotMemoryCategory {
+    const valid: PPMBotMemoryCategory[] = [
       "fact", "decision", "preference", "architecture", "issue",
     ];
-    return valid.includes(cat as ClawBotMemoryCategory)
-      ? (cat as ClawBotMemoryCategory)
+    return valid.includes(cat as PPMBotMemoryCategory)
+      ? (cat as PPMBotMemoryCategory)
       : "fact";
   }
 }

package/src/services/{clawbot/clawbot-service.ts → ppmbot/ppmbot-service.ts}

@@ -6,21 +6,21 @@ import {
   createPairingRequest,
   approvePairing,
 } from "../db.service.ts";
-import { ClawBotTelegram } from "./clawbot-telegram.ts";
-import { ClawBotSessionManager } from "./clawbot-session.ts";
-import { ClawBotMemory } from "./clawbot-memory.ts";
-import { streamToTelegram } from "./clawbot-streamer.ts";
-import { escapeHtml } from "./clawbot-formatter.ts";
-import type { TelegramUpdate, ClawBotCommand } from "../../types/clawbot.ts";
-import type { ClawBotConfig, TelegramConfig, PermissionMode } from "../../types/config.ts";
+import { PPMBotTelegram } from "./ppmbot-telegram.ts";
+import { PPMBotSessionManager } from "./ppmbot-session.ts";
+import { PPMBotMemory } from "./ppmbot-memory.ts";
+import { streamToTelegram } from "./ppmbot-streamer.ts";
+import { escapeHtml } from "./ppmbot-formatter.ts";
+import type { TelegramUpdate, PPMBotCommand } from "../../types/ppmbot.ts";
+import type { PPMBotConfig, TelegramConfig, PermissionMode } from "../../types/config.ts";
 import type { SendMessageOpts } from "../../types/chat.ts";
 
 const CONTEXT_WINDOW_THRESHOLD = 80;
 
-class ClawBotService {
-  private telegram: ClawBotTelegram | null = null;
-  private sessions = new ClawBotSessionManager();
-  private memory = new ClawBotMemory();
+class PPMBotService {
+  private telegram: PPMBotTelegram | null = null;
+  private sessions = new PPMBotSessionManager();
+  private memory = new PPMBotMemory();
   private running = false;
 
   /** Debounce timers per chatId */
@@ -39,20 +39,20 @@ class ClawBotService {
   // ── Lifecycle ─────────────────────────────────────────────────
 
   async start(): Promise<void> {
-    const clawbotConfig = this.getConfig();
-    if (!clawbotConfig?.enabled) {
-      console.log("[clawbot] Disabled in config");
+    const ppmbotConfig = this.getConfig();
+    if (!ppmbotConfig?.enabled) {
+      console.log("[ppmbot] Disabled in config");
       return;
     }
 
     const telegramConfig = configService.get("telegram") as TelegramConfig | undefined;
     if (!telegramConfig?.bot_token) {
-      console.log("[clawbot] No bot token configured");
+      console.log("[ppmbot] No bot token configured");
       return;
     }
 
     try {
-      this.telegram = new ClawBotTelegram(telegramConfig.bot_token);
+      this.telegram = new PPMBotTelegram(telegramConfig.bot_token);
       this.running = true;
 
       // Run memory decay on startup
@@ -61,9 +61,9 @@ class ClawBotService {
       // Start polling (non-blocking)
       this.telegram.startPolling((update) => this.handleUpdate(update));
 
-      console.log("[clawbot] Started");
+      console.log("[ppmbot] Started");
     } catch (err) {
-      console.error("[clawbot] Start failed:", (err as Error).message);
+      console.error("[ppmbot] Start failed:", (err as Error).message);
     }
   }
 
@@ -78,7 +78,7 @@ class ClawBotService {
     this.processing.clear();
     this.messageQueue.clear();
 
-    console.log("[clawbot] Stopped");
+    console.log("[ppmbot] Stopped");
   }
 
   get isRunning(): boolean {
@@ -89,7 +89,7 @@ class ClawBotService {
   async notifyPairingApproved(chatId: string): Promise<void> {
     await this.telegram?.sendMessage(
       Number(chatId),
-      "✅ Pairing approved! You can now chat with ClawBot.\n\nSend /start to begin.",
+      "✅ Pairing approved! You can now chat with PPMBot.\n\nSend /start to begin.",
     );
   }
 
@@ -113,14 +113,14 @@ class ClawBotService {
         createPairingRequest(chatId, String(userId), displayName, code);
         await this.telegram!.sendMessage(
           Number(chatId),
-          `🔐 Pairing required.\n\nYour pairing code: <code>${code}</code>\n\nEnter this code in PPM Settings → ClawBot → Pair Device to approve access.`,
+          `🔐 Pairing required.\n\nYour pairing code: <code>${code}</code>\n\nEnter this code in PPM Settings → PPMBot → Pair Device to approve access.`,
         );
         return;
       }
       if (pairing.status === "pending") {
         await this.telegram!.sendMessage(
           Number(chatId),
-          `⏳ Pairing pending approval.\n\nCode: <code>${pairing.pairing_code}</code>\nAsk the PPM owner to approve in Settings → ClawBot.`,
+          `⏳ Pairing pending approval.\n\nCode: <code>${pairing.pairing_code}</code>\nAsk the PPM owner to approve in Settings → PPMBot.`,
         );
         return;
       }
@@ -130,7 +130,7 @@ class ClawBotService {
     }
 
     // Try parsing as command
-    const command = ClawBotTelegram.parseCommand(message);
+    const command = PPMBotTelegram.parseCommand(message);
     if (command) {
       await this.handleCommand(command);
       return;
@@ -145,7 +145,7 @@ class ClawBotService {
 
   // ── Command Handlers ────────────────────────────────────────────
 
-  private async handleCommand(cmd: ClawBotCommand): Promise<void> {
+  private async handleCommand(cmd: PPMBotCommand): Promise<void> {
     const chatId = String(cmd.chatId);
     const tg = this.telegram!;
 
@@ -174,18 +174,35 @@ class ClawBotService {
 
   private async cmdStart(chatId: string): Promise<void> {
     const projects = this.sessions.getProjectNames();
-    let text = "<b>🤖 ClawBot</b>\n\nI'm your PPM assistant on Telegram.\n\n";
+    let text = "<b>🤖 PPMBot</b>\n\n";
+    text += "Hey! I'm your AI coding assistant, right here in Telegram.\n";
+    text += "Ask me anything — code questions, debugging, project tasks.\n\n";
     if (projects.length) {
-      text += "<b>Available projects:</b>\n";
+      text += "<b>Your projects:</b>\n";
       for (const name of projects) {
-        text += `• <code>${escapeHtml(name)}</code>\n`;
+        text += `  • <code>${escapeHtml(name)}</code>\n`;
       }
-      text += "\nSwitch project: /project &lt;name&gt;";
+      text += "\nSwitch: /project &lt;name&gt;";
     } else {
-      text += "No projects configured. Add projects in PPM settings.";
+      text += "No projects configured — I'll use a default workspace.";
     }
-    text += "\n\nSend /help for all commands.";
+    text += "\n\nJust send a message to start chatting, or /help for commands.";
     await this.telegram!.sendMessage(Number(chatId), text);
+
+    // Identity onboarding: if no identity memories exist, ask user
+    const identityMemories = this.memory.recall("_global", "user identity name role");
+    if (identityMemories.length === 0) {
+      await this.telegram!.sendMessage(
+        Number(chatId),
+        "📝 <b>Quick intro?</b>\n\n" +
+          "I don't know much about you yet! Tell me:\n" +
+          "• Your name\n" +
+          "• What you work on (language, stack, role)\n" +
+          "• Preferred response language (English, Vietnamese, etc.)\n\n" +
+          "I'll remember your preferences for future chats.\n" +
+          "Or skip this and just start chatting!",
+      );
+    }
   }
 
   private async cmdProject(chatId: string, args: string): Promise<void> {
@@ -310,7 +327,7 @@ class ClawBotService {
   }
 
   private async cmdHelp(chatId: string): Promise<void> {
-    const text = `<b>ClawBot Commands</b>
+    const text = `<b>PPMBot Commands</b>
 
 /start — Greeting + list projects
 /project &lt;name&gt; — Switch project
@@ -421,7 +438,7 @@ class ClawBotService {
         await this.rotateSession(chatId, session.projectName);
       }
     } catch (err) {
-      console.error(`[clawbot] processMessage error for ${chatId}:`, (err as Error).message);
+      console.error(`[ppmbot] processMessage error for ${chatId}:`, (err as Error).message);
       await this.telegram?.sendMessage(
         Number(chatId),
         `❌ ${escapeHtml((err as Error).message)}`,
@@ -462,15 +479,15 @@ class ClawBotService {
       const facts = this.memory.parseExtractionResponse(responseText);
       if (facts.length > 0) {
         const count = this.memory.save(session.projectName, facts, session.sessionId);
-        console.log(`[clawbot] Saved ${count} memories for ${session.projectName}`);
+        console.log(`[ppmbot] Saved ${count} memories for ${session.projectName}`);
       } else {
         // Fallback: regex-based extraction
         // Note: we don't have conversation history text here easily,
         // so regex fallback only triggers when AI extraction fails
-        console.log("[clawbot] No memories extracted via AI");
+        console.log("[ppmbot] No memories extracted via AI");
       }
     } catch (err) {
-      console.warn("[clawbot] Memory save failed:", (err as Error).message);
+      console.warn("[ppmbot] Memory save failed:", (err as Error).message);
     }
   }
 
@@ -492,9 +509,9 @@ class ClawBotService {
     return Array.from(bytes, (b) => chars[b % chars.length]).join("");
   }
 
-  private getConfig(): ClawBotConfig | undefined {
-    return configService.get("clawbot") as ClawBotConfig | undefined;
+  private getConfig(): PPMBotConfig | undefined {
+    return configService.get("clawbot") as PPMBotConfig | undefined;
   }
 }
 
-export const clawbotService = new ClawBotService();
+export const ppmbotService = new PPMBotService();