@hienlh/ppm 0.9.53 → 0.9.55

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { chatService } from "../chat.service.ts";
@@ -8,107 +8,102 @@ import {
   createPPMBotSession,
   deactivatePPMBotSession,
   touchPPMBotSession,
-  getRecentPPMBotSessions,
   getDistinctPPMBotProjectNames,
-  setSessionTitle,
 } from "../db.service.ts";
 import type { PPMBotActiveSession, PPMBotSessionRow } from "../../types/ppmbot.ts";
 import type { PPMBotConfig, ProjectConfig } from "../../types/config.ts";
 
-export class PPMBotSessionManager {
-  /** In-memory cache: telegramChatId → active session */
-  private activeSessions = new Map<string, PPMBotActiveSession>();
+export const DEFAULT_COORDINATOR_IDENTITY = `# PPMBot — AI Project Coordinator
 
-  /**
-   * Get active session for chatId. If none exists, create one for the
-   * given project (or default project from config).
-   */
-  async getOrCreateSession(
-    chatId: string,
-    projectName?: string,
-  ): Promise<PPMBotActiveSession> {
-    const cached = this.activeSessions.get(chatId);
-    if (cached && (!projectName || cached.projectName === projectName)) {
-      touchPPMBotSession(cached.sessionId);
-      return cached;
-    }
+You are PPMBot, a personal AI project coordinator and team leader. You communicate with users via Telegram.
 
-    const input = projectName || this.getDefaultProject();
-    const resolvedProject = input
-      ? this.resolveProject(input)
-      : this.getFallbackProject();
-    if (!resolvedProject) {
-      throw new Error(`Project not found: "${projectName || "(default)"}"`);
-    }
+## Role
+- Answer direct questions immediately (coding, general knowledge, quick advice)
+- Delegate project-specific tasks to subagents using \`ppm bot delegate\`
+- Track delegated task status and report results proactively
+- Remember user preferences across conversations
+- Act as a team leader coordinating work across multiple projects
 
-    const dbSession = getActivePPMBotSession(chatId, resolvedProject.name);
-    if (dbSession) {
-      return this.resumeFromDb(chatId, dbSession, resolvedProject);
-    }
+## Decision Framework
+1. Can I answer this directly without project context? → Answer now
+2. Does this reference a specific project or need file access? → Delegate
+3. Is this about PPM config or bot management? → Handle directly
+4. Ambiguous project? → Ask user to clarify
 
-    return this.createNewSession(chatId, resolvedProject);
-  }
+## Coordination Tools (via Bash)
 
-  /** Switch to a different project. Deactivates current session. */
-  async switchProject(
-    chatId: string,
-    projectName: string,
-  ): Promise<PPMBotActiveSession> {
-    await this.closeSession(chatId);
-    return this.getOrCreateSession(chatId, projectName);
-  }
+### Delegate a task to a project
+ppm bot delegate --chat <chatId> --project <name> --prompt "<enriched task description>"
+Returns task ID. Tell user you're working on it.
 
-  /** Close (deactivate) the current session for a chatId */
-  async closeSession(chatId: string): Promise<void> {
-    const active = this.activeSessions.get(chatId);
-    if (active) {
-      deactivatePPMBotSession(active.sessionId);
-      this.activeSessions.delete(chatId);
-    }
-  }
+### Check task status
+ppm bot task-status <task-id>
 
-  /** Get active session from cache (no DB hit) */
-  getActiveSession(chatId: string): PPMBotActiveSession | null {
-    return this.activeSessions.get(chatId) ?? null;
-  }
+### Get task result
+ppm bot task-result <task-id>
 
-  /** List recent sessions for a chat (from DB) */
-  listRecentSessions(chatId: string, limit = 10): PPMBotSessionRow[] {
-    return getRecentPPMBotSessions(chatId, limit);
-  }
+### List recent tasks
+ppm bot tasks
 
-  /** Resume a specific session by 1-indexed position in history */
-  async resumeSessionById(
-    chatId: string,
-    sessionIndex: number,
-  ): Promise<PPMBotActiveSession | null> {
-    const sessions = getRecentPPMBotSessions(chatId, 20);
-    const target = sessions[sessionIndex - 1];
-    if (!target) return null;
+## Response Style
+- Keep responses concise (Telegram context — mobile-friendly)
+- Use short paragraphs, no walls of text
+- When delegating: acknowledge immediately, notify on completion
+- Support Vietnamese and English naturally
 
-    await this.closeSession(chatId);
+## Important
+- When delegating, write an enriched prompt with full context — not just the raw user message
+- Include relevant details: what the user wants, which files/features, acceptance criteria
+- Each delegation creates a fresh AI session in the target project workspace
+`;
 
-    const project = this.resolveProject(target.project_name);
-    if (!project) return null;
+/** Ensure ~/.ppm/bot/ workspace exists with coordinator.md */
+export function ensureCoordinatorWorkspace(): void {
+  const botDir = join(homedir(), ".ppm", "bot");
+  const coordinatorMd = join(botDir, "coordinator.md");
+  const settingsDir = join(botDir, ".claude");
+  const settingsFile = join(settingsDir, "settings.local.json");
 
-    return this.resumeFromDb(chatId, target, project);
+  mkdirSync(botDir, { recursive: true });
+  mkdirSync(settingsDir, { recursive: true });
+
+  if (!existsSync(coordinatorMd)) {
+    writeFileSync(coordinatorMd, DEFAULT_COORDINATOR_IDENTITY);
+  }
+  if (!existsSync(settingsFile)) {
+    writeFileSync(settingsFile, JSON.stringify({
+      permissions: { allow: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"] },
+    }, null, 2));
   }
+}
+
+export class PPMBotSessionManager {
+  /** In-memory cache: telegramChatId → coordinator session */
+  private coordinatorSessions = new Map<string, PPMBotActiveSession>();
 
-  /** Resume a session by session ID prefix match */
-  async resumeSessionByIdPrefix(
-    chatId: string,
-    prefix: string,
-  ): Promise<PPMBotActiveSession | null> {
-    const sessions = getRecentPPMBotSessions(chatId, 20);
-    const target = sessions.find((s) => s.session_id.startsWith(prefix));
-    if (!target) return null;
+  /** Get or create coordinator session for chatId (always ~/.ppm/bot/) */
+  async getCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const cached = this.coordinatorSessions.get(chatId);
+    if (cached) {
+      touchPPMBotSession(cached.sessionId);
+      return cached;
+    }
 
-    await this.closeSession(chatId);
+    // Check DB for existing coordinator session
+    const dbSession = getActivePPMBotSession(chatId, "bot");
+    if (dbSession) {
+      return this.resumeFromDb(chatId, dbSession);
+    }
 
-    const project = this.resolveProject(target.project_name);
-    if (!project) return null;
+    return this.createCoordinatorSession(chatId);
+  }
 
-    return this.resumeFromDb(chatId, target, project);
+  /** Rotate coordinator session (context window near limit) */
+  async rotateCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const old = this.coordinatorSessions.get(chatId);
+    if (old) deactivatePPMBotSession(old.sessionId);
+    this.coordinatorSessions.delete(chatId);
+    return this.createCoordinatorSession(chatId);
   }
 
   /**
@@ -120,7 +115,6 @@ export class PPMBotSessionManager {
     if (!projects?.length) return null;
 
     const lower = input.toLowerCase();
-
     const exact = projects.find((p) => p.name.toLowerCase() === lower);
     if (exact) return { name: exact.name, path: exact.path };
 
@@ -130,13 +124,6 @@ export class PPMBotSessionManager {
     return null;
   }
 
-  /** Update session title (e.g. after first message) */
-  updateSessionTitle(sessionId: string, firstMessage: string): void {
-    const preview = firstMessage.slice(0, 60).replace(/\n/g, " ");
-    const title = `[PPM] ${preview}`;
-    setSessionTitle(sessionId, title);
-  }
-
   /** Get list of available project names (config + sessions history) */
   getProjectNames(): string[] {
     const configured = (configService.get("projects") as ProjectConfig[])?.map((p) => p.name) ?? [];
@@ -147,13 +134,7 @@ export class PPMBotSessionManager {
 
   // ── Private ─────────────────────────────────────────────────────
 
-  private getDefaultProject(): string {
-    const cfg = configService.get("clawbot") as PPMBotConfig | undefined;
-    return cfg?.default_project || "";
-  }
-
-  /** Fallback project when nothing is configured: ~/.ppm/bot/ */
-  private getFallbackProject(): { name: string; path: string } {
+  private getCoordinatorProject(): { name: string; path: string } {
     const botDir = join(homedir(), ".ppm", "bot");
     if (!existsSync(botDir)) mkdirSync(botDir, { recursive: true });
     return { name: "bot", path: botDir };
@@ -164,16 +145,14 @@ export class PPMBotSessionManager {
     return cfg?.default_provider || configService.get("ai").default_provider;
   }
 
-  private async createNewSession(
-    chatId: string,
-    project: { name: string; path: string },
-  ): Promise<PPMBotActiveSession> {
+  private async createCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const project = this.getCoordinatorProject();
     const providerId = this.getDefaultProvider();
 
     const session = await chatService.createSession(providerId, {
       projectName: project.name,
       projectPath: project.path,
-      title: `[PPM] New session`,
+      title: `[PPM] Coordinator`,
     });
 
     createPPMBotSession(chatId, session.id, providerId, project.name, project.path);
@@ -186,21 +165,19 @@ export class PPMBotSessionManager {
       projectPath: project.path,
     };
 
-    this.activeSessions.set(chatId, active);
+    this.coordinatorSessions.set(chatId, active);
     return active;
   }
 
-  private async resumeFromDb(
-    chatId: string,
-    dbSession: PPMBotSessionRow,
-    project: { name: string; path: string },
-  ): Promise<PPMBotActiveSession> {
+  private async resumeFromDb(chatId: string, dbSession: PPMBotSessionRow): Promise<PPMBotActiveSession> {
+    const project = this.getCoordinatorProject();
+
     try {
       await chatService.resumeSession(dbSession.provider_id, dbSession.session_id);
     } catch {
       console.warn(`[ppmbot] Failed to resume session ${dbSession.session_id}, creating new`);
       deactivatePPMBotSession(dbSession.session_id);
-      return this.createNewSession(chatId, project);
+      return this.createCoordinatorSession(chatId);
     }
 
     touchPPMBotSession(dbSession.session_id);
@@ -213,7 +190,7 @@ export class PPMBotSessionManager {
       projectPath: project.path,
     };
 
-    this.activeSessions.set(chatId, active);
+    this.coordinatorSessions.set(chatId, active);
     return active;
   }
 }

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

@@ -10,10 +10,9 @@ const POLL_TIMEOUT = 25;
 const MIN_EDIT_INTERVAL = 1000;
 const BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]{30,50}$/;
 
-/** Known PPMBot slash commands */
+/** Known PPMBot slash commands (coordinator: 3 public + 1 hidden) */
 const COMMANDS = new Set([
-  "start", "project", "new", "sessions", "resume",
-  "status", "stop", "memory", "forget", "remember", "restart", "version", "help",
+  "start", "status", "help", "restart",
 ]);
 
 export type UpdateHandler = (update: TelegramUpdate) => Promise<void>;
@@ -42,19 +41,9 @@ export class PPMBotTelegram {
     try {
       await this.callApi("setMyCommands", {
         commands: [
-          { command: "start", description: "Greeting + list projects" },
-          { 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" },
-          { command: "status", description: "Current project/session info" },
-          { command: "stop", description: "End current session" },
-          { 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: "version", description: "Show PPM version" },
-          { command: "help", description: "Show all commands" },
+          { command: "start", description: "Welcome + list projects" },
+          { command: "status", description: "Running tasks + delegations" },
+          { command: "help", description: "Show commands" },
         ],
       });
       console.log("[ppmbot] Commands registered");

package/src/services/sqlite.service.ts

@@ -137,6 +137,16 @@ class SqliteService {
     db.run(`UPDATE "${table}" SET "${column}" = ? WHERE "${pkColumn}" = ?`, [value as never, rowid]);
   }
 
+  /** Delete a row by primary key */
+  deleteRow(
+    projectPath: string, dbPath: string, table: string,
+    pkValue: unknown, pkColumn = "rowid",
+  ): void {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    db.run(`DELETE FROM "${table}" WHERE "${pkColumn}" = ?`, [pkValue as never]);
+  }
+
   /** Close all cached databases (for shutdown) */
   closeAll() {
     for (const absPath of this.cache.keys()) this.close(absPath);

package/src/types/config.ts

@@ -11,7 +11,6 @@ export interface TelegramConfig {
 export interface PPMBotConfig {
   enabled: boolean;
   default_provider: string;
-  default_project: string;
   system_prompt: string;
   show_tool_calls: boolean;
   show_thinking: boolean;
@@ -102,8 +101,7 @@ export const DEFAULT_CONFIG: PpmConfig = {
   clawbot: {
     enabled: false,
     default_provider: "claude",
-    default_project: "",
-    system_prompt: "You are PPMBot, a helpful AI coding assistant on Telegram. Keep responses concise and mobile-friendly. Use short paragraphs. When showing code, use compact examples. Be direct and helpful.",
+    system_prompt: "",
     show_tool_calls: true,
     show_thinking: false,
     permission_mode: "bypassPermissions",

package/src/types/database.ts

@@ -47,4 +47,7 @@ export interface DatabaseAdapter {
   updateCell(config: DbConnectionConfig, table: string, opts: {
     schema?: string; pkColumn: string; pkValue: unknown; column: string; value: unknown;
   }): Promise<void>;
+  deleteRow(config: DbConnectionConfig, table: string, opts: {
+    schema?: string; pkColumn: string; pkValue: unknown;
+  }): Promise<void>;
 }

package/src/types/ppmbot.ts

@@ -90,6 +90,27 @@ export interface MemoryRecallResult {
   rank?: number;
 }
 
+/** Bot task row from SQLite */
+export interface BotTask {
+  id: string;
+  chatId: string;
+  projectName: string;
+  projectPath: string;
+  prompt: string;
+  status: BotTaskStatus;
+  resultSummary: string | null;
+  resultFull: string | null;
+  sessionId: string | null;
+  error: string | null;
+  reported: boolean;
+  timeoutMs: number;
+  createdAt: number;
+  startedAt: number | null;
+  completedAt: number | null;
+}
+
+export type BotTaskStatus = "pending" | "running" | "completed" | "failed" | "timeout";
+
 /** Paired chat row from SQLite */
 export interface PPMBotPairedChat {
   id: number;

package/src/web/components/database/database-viewer.tsx

@@ -1,5 +1,5 @@
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
-import { Database, Loader2, Play, ChevronLeft, ChevronRight, RefreshCw } from "lucide-react";
+import { Database, Loader2, Play, ChevronLeft, ChevronRight, RefreshCw, Trash2 } from "lucide-react";
 import { useReactTable, getCoreRowModel, flexRender, type ColumnDef } from "@tanstack/react-table";
 import CodeMirror from "@uiw/react-codemirror";
 import { sql, PostgreSQL, SQLite } from "@codemirror/lang-sql";
@@ -51,7 +51,7 @@ export function DatabaseViewer({ metadata }: Props) {
         {/* Data grid */}
         <div className={`flex-1 overflow-hidden ${queryPanelOpen ? "max-h-[60%]" : ""}`}>
           <DataGrid tableData={db.tableData} schema={db.schema} loading={db.loading}
-            page={db.page} onPageChange={db.setPage} onCellUpdate={db.updateCell} />
+            page={db.page} onPageChange={db.setPage} onCellUpdate={db.updateCell} onRowDelete={db.deleteRow} />
         </div>
 
         {/* Query editor */}
@@ -67,14 +67,16 @@ export function DatabaseViewer({ metadata }: Props) {
 }
 
 /* ---------- Data Grid ---------- */
-function DataGrid({ tableData, schema, loading, page, onPageChange, onCellUpdate }: {
+function DataGrid({ tableData, schema, loading, page, onPageChange, onCellUpdate, onRowDelete }: {
   tableData: { columns: string[]; rows: Record<string, unknown>[]; total: number; limit: number } | null;
   schema: DbColumnInfo[]; loading: boolean; page: number;
   onPageChange: (p: number) => void;
   onCellUpdate: (pkCol: string, pkVal: unknown, col: string, val: unknown) => void;
+  onRowDelete?: (pkCol: string, pkVal: unknown) => void;
 }) {
   const [editingCell, setEditingCell] = useState<{ rowIdx: number; col: string } | null>(null);
   const [editValue, setEditValue] = useState("");
+  const [confirmDeleteIdx, setConfirmDeleteIdx] = useState<number | null>(null);
 
   const pkCol = useMemo(() => schema.find((c) => c.pk)?.name ?? null, [schema]);
 
@@ -96,8 +98,16 @@ function DataGrid({ tableData, schema, loading, page, onPageChange, onCellUpdate
 
   const cancelEdit = useCallback(() => setEditingCell(null), []);
 
-  const columns = useMemo<ColumnDef<Record<string, unknown>>[]>(() =>
-    (tableData?.columns ?? []).map((col) => ({
+  const handleDelete = useCallback((rowIdx: number) => {
+    if (!tableData || !pkCol || !onRowDelete) return;
+    const row = tableData.rows[rowIdx];
+    if (!row) return;
+    onRowDelete(pkCol, row[pkCol]);
+    setConfirmDeleteIdx(null);
+  }, [tableData, pkCol, onRowDelete]);
+
+  const columns = useMemo<ColumnDef<Record<string, unknown>>[]>(() => {
+    const dataCols: ColumnDef<Record<string, unknown>>[] = (tableData?.columns ?? []).map((col) => ({
       id: col,
       accessorFn: (row) => row[col],
       header: () => <span className={schema.find((c) => c.name === col)?.pk ? "font-bold" : ""}>{col}</span>,
@@ -118,8 +128,40 @@ function DataGrid({ tableData, schema, loading, page, onPageChange, onCellUpdate
           </span>
         );
       },
-    })),
-  [tableData?.columns, schema, editingCell, editValue, commitEdit, cancelEdit, startEdit, pkCol]);
+    }));
+
+    if (onRowDelete && pkCol) {
+      dataCols.push({
+        id: "_actions",
+        header: () => null,
+        cell: ({ row }) => {
+          const rowIdx = row.index;
+          const isConfirming = confirmDeleteIdx === rowIdx;
+          if (isConfirming) {
+            return (
+              <span className="flex items-center gap-1 whitespace-nowrap">
+                <button type="button" onClick={() => handleDelete(rowIdx)}
+                  className="text-destructive text-[10px] font-medium hover:underline">Confirm</button>
+                <button type="button" onClick={() => setConfirmDeleteIdx(null)}
+                  className="text-muted-foreground text-[10px] hover:underline">Cancel</button>
+              </span>
+            );
+          }
+          return (
+            <button type="button" onClick={() => setConfirmDeleteIdx(rowIdx)}
+              className="p-0.5 rounded opacity-0 group-hover:opacity-100 hover:bg-destructive/10 hover:text-destructive transition-opacity"
+              title="Delete row">
+              <Trash2 className="size-3" />
+            </button>
+          );
+        },
+        size: 60,
+      });
+    }
+
+    return dataCols;
+  },
+  [tableData?.columns, schema, editingCell, editValue, commitEdit, cancelEdit, startEdit, pkCol, onRowDelete, confirmDeleteIdx, handleDelete]);
 
   const table = useReactTable({ data: tableData?.rows ?? [], columns, getCoreRowModel: getCoreRowModel() });
 
@@ -150,7 +192,7 @@ function DataGrid({ tableData, schema, loading, page, onPageChange, onCellUpdate
           </thead>
           <tbody>
             {table.getRowModel().rows.map((row) => (
-              <tr key={row.id} className="hover:bg-muted/30 border-b border-border/50">
+              <tr key={row.id} className="group hover:bg-muted/30 border-b border-border/50">
                 {row.getVisibleCells().map((cell) => (
                   <td key={cell.id} className="px-2 py-1 max-w-[300px]">
                     {flexRender(cell.column.columnDef.cell, cell.getContext())}

package/src/web/components/database/use-database.ts

@@ -111,10 +111,22 @@ export function useDatabase(connectionId: number) {
     }
   }, [base, selectedTable, selectedSchema, fetchTableData]);
 
+  const deleteRow = useCallback(async (pkColumn: string, pkValue: unknown) => {
+    if (!selectedTable) return;
+    const t = selectedTable;
+    const s = selectedSchema;
+    try {
+      await api.del(`${base}/row`, { table: t, schema: s, pkColumn, pkValue });
+      fetchTableData(t, s);
+    } catch (e) {
+      setError((e as Error).message);
+    }
+  }, [base, selectedTable, selectedSchema, fetchTableData]);
+
   return {
     selectedTable, selectTable, tableData, schema,
     loading, error, page, setPage: changePage,
     queryResult, queryError, queryLoading, executeQuery,
-    updateCell, refreshData: fetchTableData,
+    updateCell, deleteRow, refreshData: fetchTableData,
   };
 }