@hienlh/ppm 0.12.6 → 0.12.8

package/src/server/routes/settings.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { configService } from "../../services/config.service.ts";
+import { configService, FILE_CONFIG_KEYS } from "../../services/config.service.ts";
 import { getConfigValue, setConfigValue, listPairedChats, getPairingByCode, approvePairing, revokePairing, getPPMBotMemories, getDb } from "../../services/db.service.ts";
 import {
   validateAIProviderConfig,
@@ -13,6 +13,7 @@ import {
 } from "../../types/config.ts";
 import { ok, err } from "../../types/api.ts";
 import { proxyService } from "../../services/proxy.service.ts";
+import { clearIndexCache } from "../../services/file-list-index.service.ts";
 import { providerRegistry } from "../../providers/registry.ts";
 
 export const settingsRoutes = new Hono();
@@ -405,6 +406,54 @@ settingsRoutes.delete("/clawbot/memories/:id", (c) => {
   }
 });
 
+// ── File Filters ──────────────────────────────────────────────────────────────
+
+/** GET /settings/files — return global file filter config */
+settingsRoutes.get("/files", (c) => {
+  return c.json(ok({
+    filesExclude: configService.getFilesExclude(),
+    searchExclude: configService.getSearchExclude(),
+    useIgnoreFiles: configService.getUseIgnoreFiles(),
+  }));
+});
+
+/** PATCH /settings/files — partial update to global file filter config */
+settingsRoutes.patch("/files", async (c) => {
+  try {
+    const body = await c.req.json<{
+      filesExclude?: string[];
+      searchExclude?: string[];
+      useIgnoreFiles?: boolean;
+    }>();
+
+    if (body.filesExclude !== undefined) {
+      if (!Array.isArray(body.filesExclude)) return c.json(err("filesExclude must be an array"), 400);
+      const patterns = body.filesExclude.filter((p) => typeof p === "string").slice(0, 200);
+      setConfigValue(FILE_CONFIG_KEYS.filesExclude, JSON.stringify(patterns));
+    }
+    if (body.searchExclude !== undefined) {
+      if (!Array.isArray(body.searchExclude)) return c.json(err("searchExclude must be an array"), 400);
+      const patterns = body.searchExclude.filter((p) => typeof p === "string").slice(0, 200);
+      setConfigValue(FILE_CONFIG_KEYS.searchExclude, JSON.stringify(patterns));
+    }
+    if (body.useIgnoreFiles !== undefined) {
+      if (typeof body.useIgnoreFiles !== "boolean") return c.json(err("useIgnoreFiles must be a boolean"), 400);
+      setConfigValue(FILE_CONFIG_KEYS.useIgnoreFiles, JSON.stringify(body.useIgnoreFiles));
+    }
+
+    // Invalidate all project index caches — global filter changes affect every project
+    clearIndexCache();
+
+    return c.json(ok({
+      filesExclude: configService.getFilesExclude(),
+      searchExclude: configService.getSearchExclude(),
+      useIgnoreFiles: configService.getUseIgnoreFiles(),
+    }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 400);
+  }
+});
+
 /** GET /settings/clawbot/tasks — list recent delegated tasks */
 settingsRoutes.get("/clawbot/tasks", (c) => {
   const limit = Number(c.req.query("limit")) || 20;

package/src/services/config.service.ts

@@ -12,6 +12,8 @@ import {
   deleteProject as dbDeleteProject,
   getDb,
   getDbFilePath,
+  getProjectSettingsJson,
+  patchProjectSettingsJson,
 } from "./db.service.ts";
 import { getPpmDir } from "./ppm-dir.ts";
 
@@ -20,6 +22,13 @@ const CONFIG_TABLE_KEYS: (keyof PpmConfig)[] = [
   "device_name", "port", "host", "theme", "auth", "ai", "push", "telegram", "clawbot",
 ];
 
+/** File filter config keys stored in the config table */
+export const FILE_CONFIG_KEYS = {
+  filesExclude: "files.exclude",
+  searchExclude: "files.searchExclude",
+  useIgnoreFiles: "files.useIgnoreFiles",
+} as const;
+
 class ConfigService {
   private config: PpmConfig = structuredClone(DEFAULT_CONFIG);
 
@@ -98,6 +107,38 @@ class ConfigService {
     return getDbFilePath();
   }
 
+  /** Get global files.exclude patterns (falls back to empty array if not set) */
+  getFilesExclude(): string[] {
+    const raw = getConfigValue(FILE_CONFIG_KEYS.filesExclude);
+    if (!raw) return [];
+    try { return JSON.parse(raw) as string[]; } catch { return []; }
+  }
+
+  /** Get global files.searchExclude patterns */
+  getSearchExclude(): string[] {
+    const raw = getConfigValue(FILE_CONFIG_KEYS.searchExclude);
+    if (!raw) return [];
+    try { return JSON.parse(raw) as string[]; } catch { return []; }
+  }
+
+  /** Get global files.useIgnoreFiles flag (default true) */
+  getUseIgnoreFiles(): boolean {
+    const raw = getConfigValue(FILE_CONFIG_KEYS.useIgnoreFiles);
+    if (raw === null) return true; // default on
+    try { return JSON.parse(raw) as boolean; } catch { return true; }
+  }
+
+  /** Get per-project settings for a given project path */
+  getProjectSettings(projectPath: string): import("../types/project.ts").ProjectSettings {
+    const json = getProjectSettingsJson(projectPath);
+    try { return JSON.parse(json) as import("../types/project.ts").ProjectSettings; } catch { return {}; }
+  }
+
+  /** Merge-patch per-project settings */
+  setProjectSettings(projectPath: string, patch: import("../types/project.ts").ProjectSettings): void {
+    patchProjectSettingsJson(projectPath, JSON.stringify(patch));
+  }
+
   /** No-op — kept for backward compatibility (init command) */
   setConfigPath(_p: string): void {}
 

package/src/services/db.service.ts

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { encrypt, decrypt } from "../lib/account-crypto.ts";
 import { getPpmDir } from "./ppm-dir.ts";
-const CURRENT_SCHEMA_VERSION = 20;
+const CURRENT_SCHEMA_VERSION = 21;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -589,6 +589,16 @@ function runMigrations(database: Database): void {
     }
     database.exec("PRAGMA user_version = 20");
   }
+
+  if (current < 21) {
+    // Add per-project settings JSON column (idempotent: check column existence first)
+    const cols = database.query("PRAGMA table_info(projects)").all() as { name: string }[];
+    const hasSettings = cols.some((c) => c.name === "settings");
+    if (!hasSettings) {
+      database.exec(`ALTER TABLE projects ADD COLUMN settings TEXT DEFAULT '{}'`);
+    }
+    database.exec("PRAGMA user_version = 21");
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -668,6 +678,52 @@ export function deleteProject(nameOrPath: string): void {
   getDb().query("DELETE FROM projects WHERE name = ? OR path = ?").run(nameOrPath, nameOrPath);
 }
 
+/** Get per-project settings JSON string (returns '{}' if missing or null) */
+export function getProjectSettingsJson(projectPath: string): string {
+  const row = getDb().query("SELECT settings FROM projects WHERE path = ?").get(projectPath) as { settings: string | null } | null;
+  return row?.settings ?? "{}";
+}
+
+/** Patch per-project settings JSON (deep merge — plain-object values are merged one level deep) */
+export function patchProjectSettingsJson(projectPath: string, patch: string): void {
+  const existing = getProjectSettingsJson(projectPath);
+
+  let existingObj: Record<string, unknown>;
+  let patchObj: Record<string, unknown>;
+  try { existingObj = (JSON.parse(existing) ?? {}) as Record<string, unknown>; }
+  catch { existingObj = {}; }
+  try { patchObj = JSON.parse(patch) as Record<string, unknown>; }
+  catch { throw new Error("Invalid patch JSON"); }
+
+  if (typeof patchObj !== "object" || patchObj === null || Array.isArray(patchObj)) {
+    throw new Error("Patch must be a plain object");
+  }
+
+  // One-level deep merge: if both sides have a plain-object value, shallow-merge; else replace
+  const merged: Record<string, unknown> = { ...existingObj };
+  for (const key of Object.keys(patchObj)) {
+    const pv = patchObj[key];
+    const ev = existingObj[key];
+    if (isPlainObject(pv) && isPlainObject(ev)) {
+      merged[key] = { ...(ev as Record<string, unknown>), ...(pv as Record<string, unknown>) };
+    } else {
+      merged[key] = pv;
+    }
+  }
+
+  const result = getDb()
+    .query("UPDATE projects SET settings = ? WHERE path = ?")
+    .run(JSON.stringify(merged), projectPath);
+
+  if ((result as { changes: number }).changes === 0) {
+    throw new Error(`Project not found: ${projectPath}`);
+  }
+}
+
+function isPlainObject(v: unknown): boolean {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+}
+
 export function updateProject(currentName: string, newName: string, newPath: string, color?: string | null): void {
   getDb().query(
     "UPDATE projects SET name = ?, path = ?, color = ? WHERE name = ?",

package/src/services/file-filter.service.ts

@@ -0,0 +1,121 @@
+/**
+ * file-filter.service.ts
+ * Resolves VS Code-style file exclude patterns for lazy-load file tree.
+ * Precedence: hardcoded defaults < global config < per-project override (last wins).
+ */
+
+import type { FileFilterConfig } from "../types/project.ts";
+import { configService } from "./config.service.ts";
+
+/** Patterns always excluded from tree listing (cannot be overridden by config) */
+export const HARDCODED_FILES_EXCLUDE = [
+  "**/.git",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+];
+
+/** Patterns always excluded from index/search */
+export const HARDCODED_SEARCH_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/build",
+  "**/.next",
+  "**/target",
+  "**/.venv",
+  "**/.cache",
+];
+
+export interface ResolvedFilter {
+  /** Combined filesExclude: hardcoded + global + project (deduped) */
+  filesExclude: string[];
+  /** Combined searchExclude: hardcoded + global + project (deduped) */
+  searchExclude: string[];
+  /** Whether to apply gitignore rules */
+  useIgnoreFiles: boolean;
+}
+
+/**
+ * Resolve final filter config for a project path.
+ * Merges: hardcoded defaults ∪ global config ∪ per-project override.
+ */
+export function resolveFilter(projectPath: string): ResolvedFilter {
+  const globalFilesExclude = configService.getFilesExclude();
+  const globalSearchExclude = configService.getSearchExclude();
+  const globalUseIgnoreFiles = configService.getUseIgnoreFiles();
+
+  const projectSettings = configService.getProjectSettings(projectPath);
+  const projectFilter: FileFilterConfig = projectSettings.files ?? {};
+
+  // Merge arrays (dedup)
+  const filesExclude = dedup([
+    ...HARDCODED_FILES_EXCLUDE,
+    ...globalFilesExclude,
+    ...(projectFilter.filesExclude ?? []),
+  ]);
+
+  const searchExclude = dedup([
+    ...HARDCODED_SEARCH_EXCLUDE,
+    ...globalSearchExclude,
+    ...(projectFilter.searchExclude ?? []),
+  ]);
+
+  // Per-project useIgnoreFiles overrides global if set
+  const useIgnoreFiles = projectFilter.useIgnoreFiles !== undefined
+    ? projectFilter.useIgnoreFiles
+    : globalUseIgnoreFiles;
+
+  return { filesExclude, searchExclude, useIgnoreFiles };
+}
+
+function dedup(arr: string[]): string[] {
+  return [...new Set(arr)];
+}
+
+/**
+ * Check if a relative path matches any of the given glob patterns.
+ * Uses simple pattern-to-regex conversion (no external lib needed).
+ * Patterns follow VS Code glob semantics: ** crosses dirs, * stays in one segment.
+ */
+export function matchesGlob(relPath: string, patterns: string[]): boolean {
+  // Normalize path separators to forward slash
+  const normalized = relPath.split("\\").join("/");
+  return patterns.some((pattern) => matchSingleGlob(normalized, pattern));
+}
+
+function matchSingleGlob(relPath: string, pattern: string): boolean {
+  // Strip leading **/ for simpler matching — handled by regex
+  const re = globPatternToRegex(pattern);
+  return re.test(relPath);
+}
+
+/**
+ * Convert a VS Code-style glob pattern to a RegExp.
+ * Cached per unique pattern string for performance.
+ */
+const regexCache = new Map<string, RegExp>();
+
+function globPatternToRegex(pattern: string): RegExp {
+  const cached = regexCache.get(pattern);
+  if (cached) return cached;
+
+  let p = pattern;
+  // Normalize path separators
+  p = p.split("\\").join("/");
+  // Strip leading ./
+  if (p.startsWith("./")) p = p.slice(2);
+
+  const escaped = p
+    .replace(/[.+^${}()|[\]]/g, "\\$&") // escape regex special chars (not * ?)
+    .replace(/\*\*/g, "\x00")            // temp: ** placeholder
+    .replace(/\*/g, "[^/]*")             // * = within one path segment
+    .replace(/\x00/g, ".*")             // ** = any path
+    .replace(/\?/g, "[^/]");            // ? = single non-slash char
+
+  // Pattern with no slash (e.g. *.log) → match at any depth
+  const re = p.includes("/")
+    ? new RegExp(`^${escaped}(/|$)`)
+    : new RegExp(`(^|/)${escaped}(/|$)`);
+
+  regexCache.set(pattern, re);
+  return re;
+}

package/src/services/file-list-index.service.ts

@@ -0,0 +1,170 @@
+/**
+ * file-list-index.service.ts
+ * Lazy-load file tree listing and flat index building for palette/search.
+ * Implements listDir() (1-level) and buildIndex() (recursive) with filter support.
+ * Index results are cached per project path and invalidated on file changes.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { resolve, relative, join } from "node:path";
+import ignore, { type Ignore } from "ignore";
+import type { FileEntry, FileDirEntry } from "../types/project.ts";
+import { matchesGlob, resolveFilter } from "./file-filter.service.ts";
+import { SecurityError, NotFoundError } from "./file.service.ts";
+
+// ---------------------------------------------------------------------------
+// Index cache keyed by absolute project path
+// ---------------------------------------------------------------------------
+
+const indexCache = new Map<string, FileEntry[]>();
+
+/** Invalidate cached flat index for a project (called on file change events) */
+export function invalidateIndexCache(projectPath: string): void {
+  indexCache.delete(projectPath);
+}
+
+/** Clear all cached indexes (e.g. for tests) */
+export function clearIndexCache(): void {
+  indexCache.clear();
+}
+
+// ---------------------------------------------------------------------------
+// Gitignore loader (shared utility)
+// ---------------------------------------------------------------------------
+
+function loadGitignore(projectPath: string): Ignore {
+  const ig = ignore();
+  const gitignorePath = join(projectPath, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    try {
+      const content = readFileSync(gitignorePath, "utf-8");
+      ig.add(content);
+    } catch { /* unreadable — skip */ }
+  }
+  return ig;
+}
+
+// ---------------------------------------------------------------------------
+// Path traversal guard
+// ---------------------------------------------------------------------------
+
+function assertWithinProject(relPath: string, projectPath: string): void {
+  const abs = resolve(projectPath, relPath);
+  if (!abs.startsWith(projectPath + "/") && abs !== projectPath) {
+    throw new SecurityError("Path traversal not allowed");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// listDir — single directory level
+// ---------------------------------------------------------------------------
+
+/**
+ * List one directory level for lazy-load file tree.
+ * Applies filesExclude patterns from resolved filter.
+ * Marks entries as isIgnored based on .gitignore (informational — still listed).
+ */
+export function listDir(projectPath: string, relPath: string): FileDirEntry[] {
+  if (relPath) assertWithinProject(relPath, projectPath);
+
+  const absDir = relPath ? resolve(projectPath, relPath) : projectPath;
+  if (!existsSync(absDir)) throw new NotFoundError(`Directory not found: ${relPath || "/"}`);
+
+  const filter = resolveFilter(projectPath);
+  const ig = filter.useIgnoreFiles ? loadGitignore(projectPath) : null;
+
+  let rawEntries;
+  try { rawEntries = readdirSync(absDir, { withFileTypes: true }); }
+  catch { return []; }
+
+  const results: FileDirEntry[] = [];
+
+  for (const entry of rawEntries) {
+    const entryRel = relPath ? `${relPath}/${entry.name}` : entry.name;
+    const entryRelPosix = entryRel.split("\\").join("/");
+
+    // Skip entries matching filesExclude (check full path and bare name)
+    if (matchesGlob(entryRelPosix, filter.filesExclude)) continue;
+    if (matchesGlob(entry.name, filter.filesExclude)) continue;
+
+    // Gitignore flag (informational only — entry still included in list)
+    let isIgnored = false;
+    if (ig) {
+      const checkPath = entry.isDirectory() ? `${entryRelPosix}/` : entryRelPosix;
+      isIgnored = ig.ignores(checkPath) || ig.ignores(entryRelPosix);
+    }
+
+    results.push({
+      name: entry.name,
+      type: entry.isDirectory() ? "directory" : "file",
+      isIgnored,
+    });
+  }
+
+  // Sort: directories first, then alphabetically
+  results.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// buildIndex — recursive flat file list
+// ---------------------------------------------------------------------------
+
+/**
+ * Build flat index of all files in project for palette/search.
+ * Applies filesExclude + searchExclude + optional gitignore.
+ * Result is cached; call invalidateIndexCache(projectPath) to bust.
+ */
+export function buildIndex(projectPath: string): FileEntry[] {
+  const cached = indexCache.get(projectPath);
+  if (cached) return cached;
+
+  const filter = resolveFilter(projectPath);
+  const ig = filter.useIgnoreFiles ? loadGitignore(projectPath) : null;
+  const allExclude = [...filter.filesExclude, ...filter.searchExclude];
+
+  const entries: FileEntry[] = [];
+  walkForIndex(projectPath, projectPath, allExclude, ig, entries);
+
+  indexCache.set(projectPath, entries);
+  return entries;
+}
+
+function walkForIndex(
+  rootPath: string,
+  dirPath: string,
+  allExclude: string[],
+  ig: Ignore | null,
+  results: FileEntry[],
+): void {
+  let dirEntries;
+  try { dirEntries = readdirSync(dirPath, { withFileTypes: true }); }
+  catch { return; }
+
+  for (const entry of dirEntries) {
+    const fullPath = join(dirPath, entry.name);
+    const relPath = relative(rootPath, fullPath);
+    const relPosix = relPath.split("\\").join("/");
+
+    // Apply glob exclusion (check full relative path and bare entry name)
+    if (matchesGlob(relPosix, allExclude)) continue;
+    if (matchesGlob(entry.name, allExclude)) continue;
+
+    // Apply gitignore rules
+    if (ig) {
+      const checkPath = entry.isDirectory() ? `${relPosix}/` : relPosix;
+      if (ig.ignores(checkPath) || ig.ignores(relPosix)) continue;
+    }
+
+    if (entry.isDirectory()) {
+      results.push({ path: relPosix, name: entry.name, type: "directory" });
+      walkForIndex(rootPath, fullPath, allExclude, ig, results);
+    } else {
+      results.push({ path: relPosix, name: entry.name, type: "file" });
+    }
+  }
+}

package/src/services/file-watcher.service.ts

@@ -16,11 +16,12 @@ interface WatchEntry {
 }
 
 const watchers = new Map<string, WatchEntry>();
-let changeCallback: ChangeCallback | null = null;
+/** Multiple callbacks supported — each is invoked on every file change event */
+const changeCallbacks: ChangeCallback[] = [];
 
-/** Register callback for file change events */
+/** Register a callback for file change events (additive — does not replace previous) */
 export function onFileChange(cb: ChangeCallback): void {
-  changeCallback = cb;
+  changeCallbacks.push(cb);
 }
 
 function shouldIgnore(filePath: string): boolean {
@@ -47,7 +48,10 @@ export function startWatching(projectName: string, projectPath: string): void {
       entry.timer = setTimeout(() => {
         const paths = [...entry.pending];
         entry.pending.clear();
-        for (const p of paths) changeCallback?.(projectName, p.replaceAll("\\", "/"));
+        for (const p of paths) {
+          const relPath = p.replaceAll("\\", "/");
+          for (const cb of changeCallbacks) cb(projectName, relPath);
+        }
       }, DEBOUNCE_MS);
     });