pi-hermes-memory 0.7.6 → 0.7.8

package/src/handlers/switch-project.ts

@@ -7,7 +7,7 @@
  * for a project they're not currently in.
  */
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { MemoryConfig } from "../types.js";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";

package/src/handlers/sync-markdown-memories.ts

@@ -5,7 +5,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { DatabaseManager } from '../store/db.js';
 import {
   parseMarkdownMemoryEntry,

package/src/index.ts

@@ -24,7 +24,7 @@
 
 import * as path from "node:path";
 import * as os from "node:os";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { MemoryStore } from "./store/memory-store.js";
 import { SkillStore } from "./store/skill-store.js";
 import { DatabaseManager } from "./store/db.js";
@@ -48,18 +48,59 @@ import { registerLearnMemoryCommand } from "./handlers/learn-memory.js";
 import { registerSyncMarkdownMemoriesCommand, syncMarkdownMemoriesToSqlite } from "./handlers/sync-markdown-memories.js";
 import { registerPreviewContextCommand } from "./handlers/preview-context.js";
 import { loadConfig } from "./config.js";
-import { detectProject } from "./project.js";
+import { detectProject, detectProjectSkills } from "./project.js";
 import { buildPromptContext } from "./prompt-context.js";
 import { migrateLegacyProjectMemoryDirs } from "./project-memory-migration.js";
 
+export function resolveProjectSkillDiscovery(
+  skillStore: SkillStore,
+  projectsMemoryDir: string | undefined,
+  cwd?: string,
+): { skillPaths: string[] } | undefined {
+  const detected = detectProjectSkills(projectsMemoryDir, cwd);
+  skillStore.setProjectContext(detected.name, detected.skillsDir);
+  if (!detected.skillsDir) return undefined;
+  return {
+    skillPaths: [detected.skillsDir],
+  };
+}
+
+export function registerProjectSkillDiscoveryHandler(
+  pi: Pick<ExtensionAPI, "on">,
+  skillStore: SkillStore,
+  projectsMemoryDir: string | undefined,
+): void {
+  pi.on("resources_discover", async (event, _ctx) => {
+    return resolveProjectSkillDiscovery(skillStore, projectsMemoryDir, (event as { cwd?: string }).cwd);
+  });
+}
+
 export default function (pi: ExtensionAPI) {
   const config = loadConfig();
 
   const globalDir = config.memoryDir ?? path.join(os.homedir(), ".pi", "agent", "memory");
+  const agentRoot = path.join(os.homedir(), ".pi", "agent");
   const store = new MemoryStore(config);
-  const skillStore = new SkillStore(path.join(globalDir, "skills"));
+  const project = detectProject(config.projectsMemoryDir);
+  const projectName = project.name ?? "";
+  const skillStore = new SkillStore({
+    globalSkillsDir: path.join(agentRoot, "skills"),
+    projectSkillsDir: project.memoryDir ? path.join(project.memoryDir, "skills") : null,
+    projectName: project.name,
+    legacySkillsDir: path.join(globalDir, "skills"),
+    migrationSentinelPath: path.join(globalDir, ".skills-migrated-to-pi-native"),
+  });
   const dbManager = new DatabaseManager(globalDir);
 
+  const refreshSkillProjectContext = (cwd?: string) => {
+    const resource = resolveProjectSkillDiscovery(skillStore, config.projectsMemoryDir, cwd);
+    return {
+      name: skillStore.getProjectName(),
+      skillsDir: skillStore.getProjectSkillsDir(),
+      resource,
+    };
+  };
+
   // Keep project memory available for users upgrading from the old
   // ~/.pi/agent/<project>/ layout. This is non-destructive: legacy folders
   // remain in place while entries are copied/merged into projects-memory/.
@@ -71,24 +112,26 @@ export default function (pi: ExtensionAPI) {
   }
 
   // Detect project from cwd using shared helper
-  const project = detectProject(config.projectsMemoryDir);
-
   // Project-scoped store: ~/.pi/agent/<projectsMemoryDir>/<project_name>/
   const projectConfig = project.memoryDir
     ? { ...config, memoryCharLimit: config.projectCharLimit, memoryDir: project.memoryDir }
     : { ...config, memoryDir: undefined };
   const projectStore = project.memoryDir ? new MemoryStore(projectConfig) : null;
-  const projectName = project.name ?? "";
 
   // ── 1. Load memory from disk on session start ──
-  pi.on("session_start", async (_event, _ctx) => {
+  pi.on("session_start", async (event, _ctx) => {
+    refreshSkillProjectContext((event as { cwd?: string }).cwd);
+    await skillStore.migrateLegacySkills();
+    await skillStore.ensureDiscoveredRoots();
     await store.loadFromDisk();
     if (projectStore) await projectStore.loadFromDisk();
   });
 
+  registerProjectSkillDiscoveryHandler(pi, skillStore, config.projectsMemoryDir);
+
   // ── 2. Inject memory policy by default; legacy mode keeps full frozen memory blocks ──
   pi.on("before_agent_start", async (event, _ctx) => {
-    const promptContext = await buildPromptContext(config, store, projectStore, skillStore, projectName);
+    const promptContext = await buildPromptContext(config, store, projectStore, projectName);
 
     if (promptContext) {
       return {
@@ -128,7 +171,7 @@ export default function (pi: ExtensionAPI) {
   registerSwitchProjectCommand(pi, config);
   registerLearnMemoryCommand(pi);
   registerSyncMarkdownMemoriesCommand(pi, dbManager, globalDir, config.projectsMemoryDir);
-  registerPreviewContextCommand(pi, store, projectStore, skillStore, projectName, config);
+  registerPreviewContextCommand(pi, store, projectStore, projectName, config);
 
   // ── 11. SQLite session search + extended memory ──
   registerSessionSearchTool(pi, dbManager);
@@ -136,25 +179,13 @@ export default function (pi: ExtensionAPI) {
   registerIndexSessionsCommand(pi);
 
   // ── 12. Auto-index session on shutdown ──
-  pi.on("session_shutdown", async (_event, _ctx) => {
+  pi.on("session_shutdown", async (_event, ctx) => {
     try {
-      const fs = require("node:fs");
-      const sessionsDir = path.join(os.homedir(), ".pi", "agent", "sessions");
-      const cwd = process.cwd();
-      const encodedCwd = cwd.replace(/\//g, "-");
-      const sessionDir = path.join(sessionsDir, encodedCwd);
-
-      if (fs.existsSync(sessionDir)) {
-        // Find the most recent JSONL file (the one we just finished)
-        const files = fs.readdirSync(sessionDir)
-          .filter((f: string) => f.endsWith(".jsonl"))
-          .sort()
-          .reverse();
-        if (files.length > 0) {
-          const sessionData = parseSessionFile(path.join(sessionDir, files[0]));
-          if (sessionData) {
-            indexSession(dbManager, sessionData);
-          }
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      if (sessionFile && require("node:fs").existsSync(sessionFile)) {
+        const sessionData = parseSessionFile(sessionFile);
+        if (sessionData) {
+          indexSession(dbManager, sessionData);
         }
       }
     } catch {

package/src/project.ts

@@ -13,6 +13,11 @@ export interface ProjectInfo {
   memoryDir: string | null;
 }
 
+export interface ProjectSkillInfo extends ProjectInfo {
+  /** Path to the project-scoped skills directory, or null. */
+  skillsDir: string | null;
+}
+
 /**
  * Detect project from the current working directory.
  *
@@ -42,3 +47,11 @@ export function detectProject(projectsMemoryDir = "projects-memory", cwd?: strin
     memoryDir: path.join(homeDir, ".pi", "agent", projectsMemoryDir, name),
   };
 }
+
+export function detectProjectSkills(projectsMemoryDir = "projects-memory", cwd?: string): ProjectSkillInfo {
+  const project = detectProject(projectsMemoryDir, cwd);
+  return {
+    ...project,
+    skillsDir: project.memoryDir ? path.join(project.memoryDir, "skills") : null,
+  };
+}

package/src/prompt-context.ts

@@ -1,7 +1,6 @@
 import { MEMORY_POLICY_PROMPT, MEMORY_POLICY_PROMPT_COMPACT } from "./constants.js";
 import type { MemoryConfig } from "./types.js";
 import type { MemoryStore } from "./store/memory-store.js";
-import type { SkillStore } from "./store/skill-store.js";
 
 type MemoryPolicyConfig = Pick<MemoryConfig, "memoryPolicyStyle" | "memoryPolicyCustomText">;
 
@@ -27,7 +26,6 @@ export async function buildPromptContext(
   config: Pick<MemoryConfig, "memoryMode" | "memoryPolicyStyle" | "memoryPolicyCustomText">,
   store: MemoryStore,
   projectStore: MemoryStore | null,
-  skillStore: SkillStore,
   projectName: string,
 ): Promise<string> {
   if (config.memoryMode === "policy-only") {
@@ -35,13 +33,11 @@ export async function buildPromptContext(
   }
 
   const memoryBlock = store.formatForSystemPrompt();
-  const skillIndex = await skillStore.formatIndexForSystemPrompt();
   const projectBlock = projectStore ? projectStore.formatProjectBlock(projectName) : "";
 
   const parts: string[] = [];
   if (memoryBlock) parts.push(memoryBlock);
   if (projectBlock) parts.push(projectBlock);
-  if (skillIndex) parts.push(skillIndex);
 
   return parts.join("\n\n");
 }

package/src/skills/procedural-skill-creator/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: procedural-skill-creator
+description: Create, patch, or improve a procedural skill using the extension's skill tool. Use when recent work should be captured as a reusable global or project-scoped procedure.
+---
+
+# Procedural Skill Creator
+
+Turn recent work into a durable procedural skill managed by the extension `skill` tool.
+
+## Goal
+
+Capture repeatable **how-to workflows** so future agents can execute them reliably.
+
+- `create` when no skill covers the workflow.
+- `patch` when an existing skill should absorb new learning.
+- skip extraction when the work is one-off.
+
+## Operating Principle
+
+Extract from what already happened first (conversation, commands, edits, failures, fixes).
+Ask follow-up questions only if critical details are missing.
+
+## Extraction Gate
+
+Save a skill only if all checks pass:
+
+1. Multi-step workflow (not a single trivial action)
+2. Likely to recur
+3. Includes non-obvious pitfalls/decision points
+4. Can be verified with concrete pass/fail checks
+
+If any check fails, respond exactly:
+
+`Nothing to extract.`
+
+## Scope Decision
+
+- `global`: portable across repos/projects
+- `project`: depends on this repo's paths, scripts, architecture, or conventions
+
+Heuristic: if repo-specific paths or commands are required, use `project`.
+
+## Global Skill De-duplication Protocol
+
+Before creating a **global** skill, prevent overlap with existing global skills.
+
+1. List skills with `skill(action="view")`.
+2. Filter to `scope=global`.
+3. Compare candidate against existing skills in three passes:
+   - **Name pass**: exact slug match or near-name match (same core verb+noun)
+   - **Description pass**: same trigger intent / same expected outcome
+   - **Procedure pass**: substantially same step sequence
+4. Decide action:
+   - **Exact same name/intent** → do **not** create; use `patch`/`edit`
+   - **Different name, same intent** → merge into existing skill (patch existing), avoid duplicate
+   - **Adjacent but distinct intent** → create new skill with sharper boundary in `When to Use`
+
+If uncertain between two similar skills, run a tie-breaker:
+- ask: "Would both skills trigger for the same user prompt and produce the same outcome?"
+- if yes, merge; if no, keep separate and clarify boundaries.
+
+Default bias: **merge over duplicate**.
+
+## Action Decision
+
+- `create`: no existing skill covers the core job
+- `patch`: existing skill exists; improve only changed section(s)
+
+Prefer patching over creating overlapping skills.
+
+## Workflow
+
+1. **Capture intent**
+   - What job should this skill enable?
+   - When should it trigger?
+   - What outcome should it produce?
+2. **Collect evidence from recent work**
+   - successful sequence
+   - dead ends and corrections
+   - verification signals
+3. **Run de-dup check** (required for global scope)
+4. **Decide** `create` / `patch` / `Nothing to extract.`
+5. **Draft or revise** using required sections:
+   - `## When to Use`
+   - `## Procedure`
+   - `## Pitfalls`
+   - `## Verification`
+6. **Run a lightweight eval pass** (before saving):
+   - one normal case
+   - one edge case
+   - one near-miss (should *not* use this skill)
+   Refine if ambiguous.
+7. **Persist with `skill` tool**
+   - create: `name`, `description`, `scope` (always explicit), full body
+   - patch: `skill_id`, `section`, section content
+
+## Authoring Standards
+
+### Name
+
+- short kebab-case (`debug-ci-timeouts`, `backfill-flag-rollout`)
+- name the reusable job, not the incident
+
+### Description (Trigger Quality)
+
+The description is the main trigger signal.
+Include:
+- what it does
+- when to use it
+- nearby phrasing users might use
+
+Be explicit enough to avoid under-triggering, without becoming spammy.
+
+### Section Quality
+
+- **When to Use**: trigger conditions + boundaries
+- **Procedure**: ordered, actionable steps
+- **Pitfalls**: frequent failure modes + prevention
+- **Verification**: concrete checks (tests, logs, files, outputs)
+
+## Generalization Guardrails
+
+- Don’t overfit to one transcript.
+- Explain *why* key steps matter when non-obvious.
+- Prefer principles + steps over rigid cargo-cult rules.
+- Keep it lean; remove steps that do not change outcomes.
+
+## Patch Guidance
+
+When patching:
+
+- use existing `skill_id`
+- patch only changed section(s)
+- prioritize `Procedure`, `Pitfalls`, `Verification`
+- avoid rewriting unrelated content
+
+## Rules
+
+- Use `skill` tool only (no direct file writes).
+- Prefer one strong skill over many near-duplicates.
+- Do not store temporary task state, ticket notes, or one-off results.
+
+## Completion Standard
+
+A saved skill must allow a future agent to execute the workflow with minimal guesswork and clear verification.
+If not, refine before saving.