@hienlh/ppm 0.9.42 → 0.9.44

package/src/server/routes/settings.ts

@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import { configService } from "../../services/config.service.ts";
-import { getConfigValue, setConfigValue, listPairedChats, getPairingByCode, approvePairing, revokePairing } from "../../services/db.service.ts";
+import { getConfigValue, setConfigValue, listPairedChats, getPairingByCode, approvePairing, revokePairing, getPPMBotMemories, getDb } from "../../services/db.service.ts";
 import {
   validateAIProviderConfig,
   validateDefaultProvider,
@@ -382,3 +382,22 @@ settingsRoutes.delete("/clawbot/paired/:chatId", (c) => {
   revokePairing(c.req.param("chatId"));
   return c.json(ok({ revoked: true }));
 });
+
+/** GET /settings/clawbot/memories?project=xxx — list memories for a project */
+settingsRoutes.get("/clawbot/memories", (c) => {
+  const project = c.req.query("project") || "_global";
+  const memories = getPPMBotMemories(project, 50);
+  return c.json(ok(memories));
+});
+
+/** DELETE /settings/clawbot/memories/:id — delete a specific memory */
+settingsRoutes.delete("/clawbot/memories/:id", (c) => {
+  const id = Number(c.req.param("id"));
+  if (!id) return c.json(err("Invalid memory ID"), 400);
+  try {
+    getDb().query("DELETE FROM clawbot_memories WHERE id = ?").run(id);
+    return c.json(ok({ deleted: id }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});

package/src/services/ppmbot/ppmbot-service.ts

@@ -5,6 +5,8 @@ import {
   getPairingByChatId,
   createPairingRequest,
   approvePairing,
+  getSessionTitles,
+  getApprovedPairedChats,
 } from "../db.service.ts";
 import { PPMBotTelegram } from "./ppmbot-telegram.ts";
 import { PPMBotSessionManager } from "./ppmbot-session.ts";
@@ -39,6 +41,9 @@ class PPMBotService {
   /** Chat IDs that just received identity onboarding prompt */
   private identityPending = new Set<string>();
 
+  /** Chat IDs where we've already checked for identity (once per session) */
+  private hasCheckedIdentity = new Set<string>();
+
   /** Message count per session for periodic memory save */
   private messageCount = new Map<string, number>();
 
@@ -70,6 +75,9 @@ class PPMBotService {
       // Start polling (non-blocking)
       this.telegram.startPolling((update) => this.handleUpdate(update));
 
+      // Check if this is a restart and notify users
+      await this.checkRestartNotification();
+
       console.log("[ppmbot] Started");
     } catch (err) {
       console.error("[ppmbot] Start failed:", (err as Error).message);
@@ -87,6 +95,7 @@ class PPMBotService {
     this.processing.clear();
     this.messageQueue.clear();
     this.identityPending.clear();
+    this.hasCheckedIdentity.clear();
     this.messageCount.clear();
 
     console.log("[ppmbot] Stopped");
@@ -172,6 +181,7 @@ class PPMBotService {
         case "memory": await this.cmdMemory(chatId); break;
         case "forget": await this.cmdForget(chatId, cmd.args); break;
         case "remember": await this.cmdRemember(chatId, cmd.args); break;
+        case "restart": await this.cmdRestart(chatId); break;
         case "help": await this.cmdHelp(chatId); break;
         default: await tg.sendMessage(Number(chatId), `Unknown command: /${cmd.command}`);
       }
@@ -201,8 +211,11 @@ class PPMBotService {
     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) {
+    const globalMemories = this.memory.getSummary("_global", 50);
+    const hasIdentity = globalMemories.some((m) =>
+      m.category === "preference" && /identity|name|role/i.test(m.content),
+    );
+    if (!hasIdentity) {
       this.identityPending.add(chatId);
       await this.telegram!.sendMessage(
         Number(chatId),
@@ -220,11 +233,20 @@ class PPMBotService {
   private async cmdProject(chatId: string, args: string): Promise<void> {
     if (!args) {
       const active = this.sessions.getActiveSession(chatId);
-      const current = active?.projectName ?? "(none)";
-      await this.telegram!.sendMessage(
-        Number(chatId),
-        `Current project: <b>${escapeHtml(current)}</b>\n\nUsage: /project &lt;name&gt;`,
-      );
+      const current = active?.projectName ?? "";
+      const projects = this.sessions.getProjectNames();
+      let text = "<b>Projects</b>\n\n";
+      if (projects.length === 0) {
+        text += "No projects configured.\nUsing default: <code>~/.ppm/bot/</code>\n";
+      } else {
+        for (const name of projects) {
+          const marker = name === current ? " ✓" : "";
+          text += `• <code>${escapeHtml(name)}</code>${marker}\n`;
+        }
+      }
+      text += `\nCurrent: <b>${escapeHtml(current || "bot (default)")}</b>`;
+      text += "\nSwitch: /project &lt;name&gt;";
+      await this.telegram!.sendMessage(Number(chatId), text);
       return;
     }
 
@@ -254,13 +276,23 @@ class PPMBotService {
       await this.telegram!.sendMessage(Number(chatId), "No recent sessions.");
       return;
     }
+
+    // Fetch titles for all sessions
+    const titles = getSessionTitles(sessions.map((s) => s.session_id));
+
     let text = "<b>Recent Sessions</b>\n\n";
     sessions.forEach((s, i) => {
       const active = s.is_active ? " ⬤" : "";
-      const date = new Date(s.last_message_at * 1000).toLocaleDateString();
-      text += `${i + 1}. <code>${escapeHtml(s.project_name)}</code> — ${date}${active}\n`;
+      const title = titles[s.session_id]?.replace(/^\[PPM\]\s*/, "") || "";
+      const preview = title ? ` — ${escapeHtml(title.slice(0, 40))}` : "";
+      const date = new Date(s.last_message_at * 1000).toLocaleString(undefined, {
+        month: "short", day: "numeric", hour: "2-digit", minute: "2-digit",
+      });
+      const sid = s.session_id.slice(0, 8);
+      text += `${i + 1}. <b>${escapeHtml(s.project_name)}</b>${preview}${active}\n`;
+      text += `   <code>${sid}</code> · ${date}\n\n`;
     });
-    text += "\nResume: /resume &lt;number&gt;";
+    text += "Resume: /resume &lt;number&gt;";
     await this.telegram!.sendMessage(Number(chatId), text);
   }
 
@@ -338,11 +370,54 @@ class PPMBotService {
     await this.telegram!.sendMessage(Number(chatId), "Remembered ✓");
   }
 
+  private async cmdRestart(chatId: string): Promise<void> {
+    await this.telegram!.sendMessage(Number(chatId), "🔄 Restarting PPM...");
+
+    // Schedule restart after a short delay so the response is sent
+    setTimeout(async () => {
+      const { join } = await import("node:path");
+      const { writeFileSync } = await import("node:fs");
+      const { homedir } = await import("node:os");
+
+      const approvedChats = getApprovedPairedChats();
+      const chatIds = approvedChats.map((c) => c.telegram_chat_id);
+
+      // Write restart marker so we can notify after restart
+      const markerPath = join(homedir(), ".ppm", "restart-notify.json");
+      writeFileSync(markerPath, JSON.stringify({ chatIds, ts: Date.now() }));
+
+      console.log("[ppmbot] Restart requested via Telegram, exiting...");
+      process.exit(0);
+    }, 500);
+  }
+
+  /** Check for restart notification marker and send notification */
+  async checkRestartNotification(): Promise<void> {
+    try {
+      const { join } = await import("node:path");
+      const { existsSync, readFileSync, unlinkSync } = await import("node:fs");
+      const { homedir } = await import("node:os");
+
+      const markerPath = join(homedir(), ".ppm", "restart-notify.json");
+      if (!existsSync(markerPath)) return;
+
+      const data = JSON.parse(readFileSync(markerPath, "utf-8"));
+      unlinkSync(markerPath);
+
+      // Only notify if restart was recent (< 60s)
+      if (Date.now() - data.ts > 60_000) return;
+
+      for (const cid of data.chatIds) {
+        await this.telegram?.sendMessage(Number(cid), "✅ PPM restarted successfully.");
+      }
+    } catch {}
+  }
+
   private async cmdHelp(chatId: string): Promise<void> {
     const text = `<b>PPMBot Commands</b>
 
 /start — Greeting + list projects
-/project &lt;name&gt; — Switch project
+/project &lt;name&gt; — Switch/list projects
 /new — Fresh session (current project)
 /sessions — List recent sessions
 /resume &lt;n&gt; — Resume session #n
@@ -351,6 +426,7 @@ class PPMBotService {
 /memory — Show project memories
 /forget &lt;topic&gt; — Remove matching memories
 /remember &lt;fact&gt; — Save a fact
+/restart — Restart PPM server
 /help — This message`;
     await this.telegram!.sendMessage(Number(chatId), text);
   }
@@ -442,11 +518,19 @@ class PPMBotService {
         },
       );
 
-      // Capture identity if onboarding was just shown
+      // Capture identity: save when onboarding was shown OR when no identity exists
+      // (handles server restarts losing the in-memory flag)
       if (this.identityPending.has(chatId)) {
         this.identityPending.delete(chatId);
         this.memory.saveOne("_global", `User identity: ${text}`, "preference", session.sessionId);
         console.log("[ppmbot] Saved identity memory from onboarding");
+      } else if (!this.hasCheckedIdentity.has(chatId)) {
+        this.hasCheckedIdentity.add(chatId);
+        const globalMems = this.memory.getSummary("_global", 50);
+        if (!globalMems.some((m) => m.category === "preference" && /identity/i.test(m.content))) {
+          this.memory.saveOne("_global", `User identity: ${text}`, "preference", session.sessionId);
+          console.log("[ppmbot] Saved identity memory (first message, no identity found)");
+        }
       }
 
       // Periodic memory extraction — fire-and-forget every N messages

package/src/services/ppmbot/ppmbot-telegram.ts

@@ -13,7 +13,7 @@ const BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]{30,50}$/;
 /** Known PPMBot slash commands */
 const COMMANDS = new Set([
   "start", "project", "new", "sessions", "resume",
-  "status", "stop", "memory", "forget", "remember", "help",
+  "status", "stop", "memory", "forget", "remember", "restart", "help",
 ]);
 
 export type UpdateHandler = (update: TelegramUpdate) => Promise<void>;
@@ -43,7 +43,7 @@ export class PPMBotTelegram {
       await this.callApi("setMyCommands", {
         commands: [
           { command: "start", description: "Greeting + list projects" },
-          { command: "project", description: "Switch project" },
+          { command: "project", description: "Switch/list projects" },
           { command: "new", description: "Fresh session (current project)" },
           { command: "sessions", description: "List recent sessions" },
           { command: "resume", description: "Resume a previous session" },
@@ -52,6 +52,7 @@ export class PPMBotTelegram {
           { command: "memory", description: "Show project memories" },
           { command: "forget", description: "Remove matching memories" },
           { command: "remember", description: "Save a fact" },
+          { command: "restart", description: "Restart PPM server" },
           { command: "help", description: "Show all commands" },
         ],
       });

package/src/web/components/settings/ppmbot-settings-section.tsx

@@ -3,7 +3,8 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Switch } from "@/components/ui/switch";
 import { api } from "@/lib/api-client";
-import { Trash2, CheckCircle, Clock, Send } from "lucide-react";
+import { Trash2, CheckCircle, Clock, Send, Brain, RefreshCw } from "lucide-react";
+import { Separator } from "@/components/ui/separator";
 
 interface PPMBotConfig {
   enabled: boolean;
@@ -20,6 +21,14 @@ interface TelegramConfig {
   bot_token: string;
 }
 
+interface MemoryRow {
+  id: number;
+  project: string;
+  content: string;
+  category: string;
+  importance: number;
+}
+
 interface PairedChat {
   id: number;
   telegram_chat_id: string;
@@ -53,6 +62,9 @@ export function PPMBotSettingsSection() {
   const [approving, setApproving] = useState(false);
   const [testing, setTesting] = useState(false);
 
+  const [memories, setMemories] = useState<MemoryRow[]>([]);
+  const [memoryProject, setMemoryProject] = useState("_global");
+
   const fetchPairedChats = useCallback(async () => {
     try {
       const data = await api.get<PairedChat[]>("/api/settings/clawbot/paired");
@@ -60,6 +72,20 @@ export function PPMBotSettingsSection() {
     } catch {}
   }, []);
 
+  const fetchMemories = useCallback(async (project = memoryProject) => {
+    try {
+      const data = await api.get<MemoryRow[]>(`/api/settings/clawbot/memories?project=${encodeURIComponent(project)}`);
+      setMemories(data);
+    } catch {}
+  }, [memoryProject]);
+
+  const deleteMemory = async (id: number) => {
+    try {
+      await api.del(`/api/settings/clawbot/memories/${id}`);
+      setMemories((prev) => prev.filter((m) => m.id !== id));
+    } catch {}
+  };
+
   useEffect(() => {
     api.get<PPMBotConfig>("/api/settings/clawbot").then((data) => {
       setConfig(data);
@@ -74,7 +100,8 @@ export function PPMBotSettingsSection() {
       setTokenConfigured(!!data.bot_token);
     }).catch(() => {});
     fetchPairedChats();
-  }, [fetchPairedChats]);
+    fetchMemories("_global");
+  }, [fetchPairedChats, fetchMemories]);
 
   const saveToken = async () => {
     if (!tokenInput.trim()) return;
@@ -276,6 +303,61 @@ export function PPMBotSettingsSection() {
         )}
       </div>
 
+      <Separator />
+
+      {/* Memory & Identity */}
+      <div className="space-y-2">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-1.5">
+            <Brain className="size-3.5 text-muted-foreground" />
+            <p className="text-xs font-medium">Memory & Identity</p>
+          </div>
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-6 w-6 p-0 cursor-pointer"
+            onClick={() => fetchMemories(memoryProject)}
+          >
+            <RefreshCw className="size-3" />
+          </Button>
+        </div>
+        <p className="text-[10px] text-muted-foreground">
+          Facts the bot remembers across sessions. Use /remember on Telegram to add, or delete here.
+        </p>
+
+        {memories.length === 0 ? (
+          <p className="text-[10px] text-muted-foreground italic">
+            No memories stored yet. Send /start on Telegram and introduce yourself.
+          </p>
+        ) : (
+          <div className="space-y-1 max-h-[200px] overflow-y-auto">
+            {memories.map((mem) => (
+              <div
+                key={mem.id}
+                className="flex items-start justify-between rounded-md border p-2 gap-1"
+              >
+                <div className="min-w-0 flex-1">
+                  <p className="text-[11px] break-words">{mem.content}</p>
+                  <p className="text-[10px] text-muted-foreground">
+                    {mem.category} · {mem.project}
+                  </p>
+                </div>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-6 w-6 p-0 text-destructive hover:text-destructive cursor-pointer shrink-0"
+                  onClick={() => deleteMemory(mem.id)}
+                >
+                  <Trash2 className="size-3" />
+                </Button>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+
+      <Separator />
+
       {/* Default Project */}
       <div className="space-y-1.5">
         <label className="text-[11px] text-muted-foreground">Default Project</label>