pi-hermes-memory 0.7.8 → 0.7.10

package/src/store/skill-store.ts

@@ -1,7 +1,7 @@
 /**
  * SkillStore — procedural memory stored as Pi-native skills.
  *
- * Global skills live in ~/.pi/agent/skills/<slug>/SKILL.md.
+ * Global skills live in ~/.pi/agent/pi-hermes-memory/skills/<slug>/SKILL.md.
  * Project skills live in ~/.pi/agent/<projectsMemoryDir>/<project>/skills/<slug>/SKILL.md.
  */
 
@@ -27,6 +27,7 @@ interface SkillStoreOptions {
   projectSkillsDir?: string | null;
   projectName?: string | null;
   legacySkillsDir?: string;
+  legacyPiGlobalSkillsDir?: string;
   migrationSentinelPath?: string;
 }
 
@@ -50,6 +51,7 @@ export class SkillStore {
   private projectSkillsDir: string | null;
   private projectName: string | null;
   private legacySkillsDir: string;
+  private legacyPiGlobalSkillsDir: string;
   private migrationSentinelPath: string;
 
   constructor(options: SkillStoreOptions = {}) {
@@ -58,8 +60,9 @@ export class SkillStore {
     this.projectSkillsDir = options.projectSkillsDir ?? null;
     this.projectName = options.projectName ?? null;
     this.legacySkillsDir = options.legacySkillsDir ?? path.join(agentRoot, "memory", "skills");
+    this.legacyPiGlobalSkillsDir = options.legacyPiGlobalSkillsDir ?? path.join(agentRoot, "skills");
     this.migrationSentinelPath = options.migrationSentinelPath
-      ?? path.join(agentRoot, "memory", ".skills-migrated-to-pi-native");
+      ?? path.join(agentRoot, "pi-hermes-memory", ".skills-migrated-to-extension-storage");
   }
 
   getGlobalSkillsDir(): string {
@@ -89,52 +92,17 @@ export class SkillStore {
   async migrateLegacySkills(): Promise<LegacySkillMigrationResult> {
     const result: LegacySkillMigrationResult = { migrated: 0, skipped: 0, warnings: [] };
 
+    // Always normalize flat markdown files under the global skills root,
+    // even when a previous migration sentinel already exists.
+    await this.migrateFlatMarkdownInGlobalSkillsDir(result);
+
     if (await exists(this.migrationSentinelPath)) return result;
 
     await fs.mkdir(path.dirname(this.migrationSentinelPath), { recursive: true });
 
     try {
-      if (!await exists(this.legacySkillsDir)) return result;
-
-      const files = (await fs.readdir(this.legacySkillsDir))
-        .filter((file) => file.endsWith(".md"))
-        .sort();
-
-      for (const file of files) {
-        const legacyPath = path.join(this.legacySkillsDir, file);
-        try {
-          const raw = await fs.readFile(legacyPath, "utf-8");
-          const parsed = parseFrontmatter(raw);
-          const fallbackSlug = slugify(path.basename(file, ".md"));
-          const slug = slugify(parsed.meta.name || fallbackSlug);
-          if (!slug) {
-            result.skipped++;
-            continue;
-          }
-
-          const targetPath = path.join(this.globalSkillsDir, slug, "SKILL.md");
-          if (await exists(targetPath)) {
-            result.skipped++;
-            continue;
-          }
-
-          const skillDoc = {
-            name: slug,
-            displayName: parsed.meta.display_name?.trim() || parsed.meta.name?.trim() || undefined,
-            description: parsed.meta.description?.trim() || `Migrated legacy skill: ${slug}`,
-            version: Number.parseInt(parsed.meta.version || "1", 10) || 1,
-            created: parsed.meta.created || today(),
-            updated: parsed.meta.updated || today(),
-            body: parsed.body || `# ${slug}\n`,
-          };
-
-          await fs.mkdir(path.dirname(targetPath), { recursive: true });
-          await this.atomicWrite(targetPath, formatFrontmatter(skillDoc));
-          result.migrated++;
-        } catch (error) {
-          result.warnings.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
+      await this.migrateLegacyMarkdownSkills(result);
+      await this.migrateLegacyPiGlobalSkillDirs(result);
     } finally {
       if (result.warnings.length === 0) {
         await fs.writeFile(this.migrationSentinelPath, `${new Date().toISOString()}\n`, "utf-8");
@@ -144,6 +112,137 @@ export class SkillStore {
     return result;
   }
 
+  private async migrateLegacyMarkdownSkills(result: LegacySkillMigrationResult): Promise<void> {
+    if (!await exists(this.legacySkillsDir)) return;
+
+    const files = (await fs.readdir(this.legacySkillsDir))
+      .filter((file) => file.endsWith(".md"))
+      .sort();
+
+    for (const file of files) {
+      const legacyPath = path.join(this.legacySkillsDir, file);
+      try {
+        const raw = await fs.readFile(legacyPath, "utf-8");
+        const parsed = parseFrontmatter(raw);
+        const fallbackSlug = slugify(path.basename(file, ".md"));
+        const slug = slugify(parsed.meta.name || fallbackSlug);
+        if (!slug) {
+          result.skipped++;
+          continue;
+        }
+
+        const targetPath = path.join(this.globalSkillsDir, slug, "SKILL.md");
+        if (await exists(targetPath)) {
+          result.skipped++;
+          continue;
+        }
+
+        const skillDoc = {
+          name: slug,
+          displayName: parsed.meta.display_name?.trim() || parsed.meta.name?.trim() || undefined,
+          description: parsed.meta.description?.trim() || `Migrated legacy skill: ${slug}`,
+          version: Number.parseInt(parsed.meta.version || "1", 10) || 1,
+          created: parsed.meta.created || today(),
+          updated: parsed.meta.updated || today(),
+          body: parsed.body || `# ${slug}\n`,
+        };
+
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await this.atomicWrite(targetPath, formatFrontmatter(skillDoc));
+        result.migrated++;
+      } catch (error) {
+        result.warnings.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+
+  private async migrateFlatMarkdownInGlobalSkillsDir(result: LegacySkillMigrationResult): Promise<void> {
+    if (!await exists(this.globalSkillsDir)) return;
+
+    const files = (await fs.readdir(this.globalSkillsDir))
+      .filter((file) => file.endsWith(".md") && file !== "SKILL.md")
+      .sort();
+
+    for (const file of files) {
+      const legacyPath = path.join(this.globalSkillsDir, file);
+      try {
+        const raw = await fs.readFile(legacyPath, "utf-8");
+        const parsed = parseFrontmatter(raw);
+        const fallbackSlug = slugify(path.basename(file, ".md"));
+        const slug = slugify(parsed.meta.name || fallbackSlug);
+        if (!slug) {
+          result.skipped++;
+          continue;
+        }
+
+        const targetPath = path.join(this.globalSkillsDir, slug, "SKILL.md");
+        if (await exists(targetPath)) {
+          await fs.rm(legacyPath, { force: true });
+          result.skipped++;
+          continue;
+        }
+
+        const skillDoc = {
+          name: slug,
+          displayName: parsed.meta.display_name?.trim() || parsed.meta.name?.trim() || undefined,
+          description: parsed.meta.description?.trim() || `Migrated legacy skill: ${slug}`,
+          version: Number.parseInt(parsed.meta.version || "1", 10) || 1,
+          created: parsed.meta.created || today(),
+          updated: parsed.meta.updated || today(),
+          body: parsed.body || `# ${slug}\n`,
+        };
+
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await this.atomicWrite(targetPath, formatFrontmatter(skillDoc));
+        await fs.rm(legacyPath, { force: true });
+        result.migrated++;
+      } catch (error) {
+        result.warnings.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+
+  private async migrateLegacyPiGlobalSkillDirs(result: LegacySkillMigrationResult): Promise<void> {
+    if (path.resolve(this.legacyPiGlobalSkillsDir) === path.resolve(this.globalSkillsDir)) return;
+    if (!await exists(this.legacyPiGlobalSkillsDir)) return;
+
+    const entries = await fs.readdir(this.legacyPiGlobalSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+
+      const sourceDir = path.join(this.legacyPiGlobalSkillsDir, entry.name);
+      const sourceSkill = path.join(sourceDir, "SKILL.md");
+      if (!await exists(sourceSkill)) continue;
+
+      const targetDir = path.join(this.globalSkillsDir, entry.name);
+      const targetSkill = path.join(targetDir, "SKILL.md");
+      if (await exists(targetSkill)) {
+        result.skipped++;
+        continue;
+      }
+
+      try {
+        const raw = await fs.readFile(sourceSkill, "utf-8");
+        const parsed = parseFrontmatter(raw);
+        const hasExtensionManagedMeta = Boolean(parsed.meta.display_name)
+          && Boolean(parsed.meta.created)
+          && Boolean(parsed.meta.updated)
+          && /^\d+$/.test(parsed.meta.version ?? "");
+
+        if (!hasExtensionManagedMeta) {
+          result.skipped++;
+          continue;
+        }
+
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        await fs.rename(sourceDir, targetDir);
+        result.migrated++;
+      } catch (error) {
+        result.warnings.push(`${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+
   async loadIndex(scope?: SkillScope): Promise<SkillIndex[]> {
     const locations = await this.collectLocations(scope);
     const skills: SkillIndex[] = [];

package/src/store/skill-utils.ts

@@ -6,6 +6,19 @@ export interface ParsedSkillFile {
   body: string;
 }
 
+function parseScalar(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+      // fall through to raw trimmed
+    }
+  }
+  return trimmed;
+}
+
 export function parseFrontmatter(raw: string): ParsedSkillFile {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) return { meta: {}, body: raw.trim() };
@@ -15,7 +28,7 @@ export function parseFrontmatter(raw: string): ParsedSkillFile {
     const idx = line.indexOf(":");
     if (idx > 0) {
       const key = line.slice(0, idx).trim();
-      const value = line.slice(idx + 1).trim();
+      const value = parseScalar(line.slice(idx + 1));
       meta[key] = value;
     }
   }
@@ -23,18 +36,22 @@ export function parseFrontmatter(raw: string): ParsedSkillFile {
   return { meta, body: match[2].trim() };
 }
 
+function yamlDoubleQuoted(value: string): string {
+  return JSON.stringify(value);
+}
+
 export function formatFrontmatter(doc: Pick<SkillDocument, "name" | "displayName" | "description" | "version" | "created" | "updated" | "body">): string {
   const lines = [
     "---",
-    `name: ${doc.name}`,
-    `description: ${doc.description}`,
+    `name: ${yamlDoubleQuoted(doc.name)}`,
+    `description: ${yamlDoubleQuoted(doc.description)}`,
     `version: ${doc.version}`,
-    `created: ${doc.created}`,
-    `updated: ${doc.updated}`,
+    `created: ${yamlDoubleQuoted(doc.created)}`,
+    `updated: ${yamlDoubleQuoted(doc.updated)}`,
   ];
 
   if (doc.displayName && doc.displayName.trim() && doc.displayName.trim() !== doc.name) {
-    lines.push(`display_name: ${doc.displayName.trim()}`);
+    lines.push(`display_name: ${yamlDoubleQuoted(doc.displayName.trim())}`);
   }
 
   lines.push("---", doc.body);

package/src/tools/session-search-tool.ts

@@ -1,17 +1,122 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { DatabaseManager } from '../store/db.js';
 import { searchSessions, getIndexedMessageCount } from '../store/session-search.js';
+import { searchSessionAnchors } from '../store/session-anchor-search.js';
+import type { SessionAnchorRange, SessionAnchorSearchResult } from '../store/session-anchor-search.js';
+import type { SessionSearchConfig } from '../types.js';
 
 interface SearchResult {
   success: boolean;
   count?: number;
   message?: string;
   output?: string;
+  ranges?: SessionAnchorRange[];
 }
 
-export function registerSessionSearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+interface SessionSearchToolOptions {
+  sessionsDir?: string;
+}
+
+const DEFAULT_SESSIONS_DIR = path.join(os.homedir(), '.pi', 'agent', 'sessions');
+
+export function registerSessionSearchTool(
+  pi: ExtensionAPI,
+  dbManager: DatabaseManager,
+  sessionSearchConfig: SessionSearchConfig = { variant: 'legacy' },
+  options: SessionSearchToolOptions = {},
+): void {
+  if (sessionSearchConfig.variant === 'anchors') {
+    registerAnchorSessionSearchTool(pi, options.sessionsDir ?? DEFAULT_SESSIONS_DIR);
+    return;
+  }
+
+  registerLegacySessionSearchTool(pi, dbManager);
+}
+
+function registerAnchorSessionSearchTool(pi: ExtensionAPI, sessionsDir: string): void {
+  pi.registerTool({
+    name: 'session_search',
+    label: 'Session Search',
+    description: `Search Pi session JSONL files in the opt-in anchor mode using a Markdown request.
+
+This mode accepts only a markdown request. Supported scalar fields are from, to, cwd, and limit. Supported list sections are all, any, and exclude: all terms must match, any requires at least one listed term, and exclude removes matching ranges. It returns compact JSONL line-range anchors, not summaries or previews. Output is plain text: count, optional message, then anchors as path:startLine-endLine with a short reason.
+
+Example:
+from: 2026-05-14
+to: 2026-05-15
+cwd: /path/to/project
+limit: 20
+
+all:
+- alpha
+
+any:
+- beta
+- gamma
+
+exclude:
+- delta`,
+    promptSnippet: 'Search past session JSONL files for compact source anchors',
+    promptGuidelines: [
+      'Use session_search with markdown only when the session search anchor mode is configured.',
+      'Request source anchors, not summaries or previews.',
+      'Use all for required terms, any for alternatives, and exclude for terms that must not appear in a returned range.',
+    ],
+    parameters: Type.Object({
+      markdown: Type.String({ description: 'Markdown request with optional from/to/cwd/limit fields and all/any/exclude lists.' }),
+    }),
+    execute: async (_id: string, args: { markdown: string }) => {
+      const markdown = args.markdown;
+
+      if (!markdown || markdown.trim().length === 0) {
+        const result: SearchResult = { success: false, message: 'markdown is required' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const searchResult = searchSessionAnchors(markdown, { sessionsDir });
+      if (!searchResult.success) {
+        const result: SearchResult = { success: false, message: searchResult.message ?? 'Anchor session search failed.' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const output = formatAnchorSearchOutput(searchResult);
+      const result: SearchResult = {
+        success: true,
+        count: searchResult.ranges.length,
+        message: searchResult.message,
+        output,
+        ranges: searchResult.ranges,
+      };
+      return { content: [{ type: 'text' as const, text: output }], details: result };
+    },
+  });
+}
+
+function formatAnchorSearchOutput(searchResult: SessionAnchorSearchResult): string {
+  const lines = [`count: ${searchResult.ranges.length}`];
+  if (searchResult.message) lines.push(`message: ${searchResult.message}`);
+  if (searchResult.ranges.length > 0) {
+    lines.push("anchors:");
+    for (const range of searchResult.ranges) {
+      const anchor = `${range.path}:${range.startLine}-${range.endLine}`;
+      const reason = compactReason(range.reason);
+      lines.push(reason ? `- ${anchor} — ${reason}` : `- ${anchor}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function compactReason(reason: string | undefined): string {
+  if (!reason) return "";
+  const oneLine = reason.replace(/\s+/g, " ").trim();
+  return oneLine.length <= 180 ? oneLine : `${oneLine.slice(0, 177)}...`;
+}
+
+function registerLegacySessionSearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
   pi.registerTool({
     name: 'session_search',
     label: 'Session Search',

package/src/types.ts

@@ -6,6 +6,13 @@ import type { TextContent } from "@earendil-works/pi-ai";
 
 export type MemoryOverflowStrategy = "auto-consolidate" | "reject" | "fifo-evict";
 
+export type SessionSearchVariant = "legacy" | "anchors";
+
+export interface SessionSearchConfig {
+  /** Session search implementation variant. Default: legacy */
+  variant: SessionSearchVariant;
+}
+
 export interface MemoryConfig {
   /** Prompt memory mode. Default: policy-only */
   memoryMode: "policy-only" | "legacy-inject";
@@ -33,10 +40,12 @@ export interface MemoryConfig {
   flushMinTurns: number;
   /** Recent conversation messages included in session flush. 0 = all. Default: 0 */
   flushRecentMessages?: number;
-  /** Override memory directory. Default: ~/.pi/agent/memory */
+  /** Override extension storage directory. Default: ~/.pi/agent/pi-hermes-memory */
   memoryDir?: string;
   /** Directory for project-scoped memory (relative to ~/.pi/agent). Default: "projects-memory" */
   projectsMemoryDir?: string;
+  /** Session search configuration. Default: { variant: "legacy" } */
+  sessionSearch?: SessionSearchConfig;
   /** Strategy when memory is full. Default: auto-consolidate */
   memoryOverflowStrategy?: MemoryOverflowStrategy;
   /** Legacy alias for memoryOverflowStrategy. Default: true */
@@ -61,10 +70,6 @@ export interface MemoryConfig {
   nudgeToolCalls: number;
   /** Maximum time in milliseconds for auto-consolidation to complete. Default: 60000 */
   consolidationTimeoutMs: number;
-  /** Enable session history search via SQLite FTS5. Default: true */
-  sessionSearchEnabled?: boolean;
-  /** Days to retain session history. Default: 90 */
-  sessionRetentionDays?: number;
 }
 
 export type MemoryCategory =