lsd-pi 1.0.0 → 1.1.1

package/dist/resources/extensions/memory/memory-scan.js

@@ -0,0 +1,90 @@
+/**
+ * Memory scanner — reads .md topic files from a memory directory,
+ * parses YAML frontmatter, and returns structured headers.
+ *
+ * All operations are synchronous (runs during prompt building in extension hooks).
+ * Errors are handled gracefully — never throws, returns empty results on failure.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+/** Maximum number of memory files to return */
+const MAX_MEMORY_FILES = 200;
+/** Only read the first 2KB of each file for frontmatter extraction */
+const FRONTMATTER_MAX_BYTES = 2048;
+const VALID_TYPES = new Set(['user', 'feedback', 'project', 'reference']);
+/**
+ * Parse YAML frontmatter from the beginning of a markdown string.
+ * Expects `---\n` delimiters. Returns an empty object on malformed input.
+ */
+export function parseFrontmatter(content) {
+    if (!content.startsWith('---\n') && !content.startsWith('---\r\n'))
+        return {};
+    const endIdx = content.indexOf('\n---', 4);
+    if (endIdx === -1)
+        return {};
+    const block = content.slice(4, endIdx);
+    const result = {};
+    const lineRe = /^(\w+):\s*(.+)$/;
+    for (const line of block.split('\n')) {
+        const m = line.trim().match(lineRe);
+        if (m)
+            result[m[1]] = m[2];
+    }
+    return result;
+}
+/**
+ * Scan a memory directory for `.md` topic files, parse their frontmatter,
+ * and return structured headers sorted by modification time (newest first).
+ */
+export function scanMemoryFiles(memoryDir) {
+    let entries;
+    try {
+        entries = readdirSync(memoryDir, { recursive: true });
+    }
+    catch {
+        return [];
+    }
+    const headers = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.md') || basename(entry) === 'MEMORY.md')
+            continue;
+        const filePath = join(memoryDir, entry);
+        try {
+            const stat = statSync(filePath);
+            if (!stat.isFile())
+                continue;
+            const raw = readFileSync(filePath);
+            const snippet = raw.slice(0, FRONTMATTER_MAX_BYTES).toString('utf-8');
+            const fm = parseFrontmatter(snippet);
+            const rawType = fm.type?.toLowerCase();
+            headers.push({
+                filename: entry,
+                filePath,
+                mtimeMs: stat.mtimeMs,
+                description: fm.description ?? null,
+                type: VALID_TYPES.has(rawType)
+                    ? rawType
+                    : undefined,
+            });
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    headers.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return headers.slice(0, MAX_MEMORY_FILES);
+}
+/**
+ * Format an array of memory headers into a human-readable manifest string.
+ * One line per memory: `- [type] filename (ISO-date): description`
+ */
+export function formatMemoryManifest(memories) {
+    return memories
+        .map((m) => {
+        const tag = m.type ? `[${m.type}] ` : '';
+        const date = new Date(m.mtimeMs).toISOString().slice(0, 10);
+        const desc = m.description ? `: ${m.description}` : '';
+        return `- ${tag}${m.filename} (${date})${desc}`;
+    })
+        .join('\n');
+}

package/dist/resources/extensions/memory/memory-types.js

@@ -0,0 +1,96 @@
+/**
+ * Memory type taxonomy for the LSD memory extension.
+ *
+ * Defines the four memory categories, a parser, frontmatter template,
+ * and guidance sections that are injected into the agent system prompt.
+ */
+/** The four canonical memory types. */
+export const MEMORY_TYPES = ['user', 'feedback', 'project', 'reference'];
+/**
+ * Parse an unknown value into a {@link MemoryType}.
+ * Returns `undefined` when the value is not a recognised type string.
+ */
+export function parseMemoryType(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    return MEMORY_TYPES.find(t => t === raw);
+}
+/** Example frontmatter block shown to the agent when creating memories. */
+export const MEMORY_FRONTMATTER_EXAMPLE = [
+    '```markdown',
+    '---',
+    'name: {{memory name}}',
+    'description: {{one-line description — used to decide relevance in future conversations, so be specific}}',
+    `type: {{${MEMORY_TYPES.join(', ')}}}`,
+    '---',
+    '',
+    '{{memory content — for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}}',
+    '```',
+];
+// ---------------------------------------------------------------------------
+// Guidance sections – injected into the system prompt so the agent knows
+// how to categorise, recall, and trust memories.
+// ---------------------------------------------------------------------------
+/** Describes each memory type with when-to-save guidance and examples. */
+export const TYPES_SECTION = [
+    '<types>',
+    '',
+    '**user** — Personal preferences, conventions, and workflow habits.',
+    'Save when the user states a preference or corrects your behaviour.',
+    'Example: "User prefers single quotes and no semicolons in TypeScript."',
+    '',
+    '**feedback** — Explicit corrections or praise about agent behaviour.',
+    'Save when the user says "remember this", "don\'t do that again", or gives direct feedback.',
+    'Example: "When refactoring, never rename public API symbols without asking first.',
+    '**Why:** Renaming broke downstream consumers last time.',
+    '**How to apply:** Always confirm public renames before executing."',
+    '',
+    '**project** — Architecture decisions, repo conventions, and domain knowledge.',
+    'Save when you discover non-obvious project structure or the user explains a design choice.',
+    'Example: "All API routes live under src/api/ and must export a default handler.',
+    '**Why:** The deploy pipeline relies on this convention for tree-shaking.',
+    '**How to apply:** When creating new endpoints, place them in src/api/ with a default export."',
+    '',
+    '**reference** — Useful facts, links, snippets, or documentation pointers.',
+    'Save when the user shares a reference they may need again or you find a useful resource.',
+    'Example: "The internal design-tokens spec lives at https://wiki.internal/tokens-v3."',
+    '',
+    '</types>',
+];
+/** Things that should NOT be saved as memories. */
+export const WHAT_NOT_TO_SAVE_SECTION = [
+    '<what_not_to_save>',
+    '',
+    '- Raw code snippets or implementation details — they belong in source files, not memories.',
+    '- Git history, commit messages, or PR descriptions — already tracked by version control.',
+    '- One-off debugging solutions unlikely to recur (e.g. "ran npm cache clean to fix install").',
+    '- Anything already captured in lsd.md or project README — avoid duplication.',
+    '- Ephemeral task details: ticket numbers, branch names, WIP progress, or session-specific context.',
+    '',
+    '</what_not_to_save>',
+];
+/** When the agent should access (recall) memories. */
+export const WHEN_TO_ACCESS_SECTION = [
+    '<when_to_access>',
+    '',
+    '- When a recalled memory is directly relevant to the current task or question.',
+    '- When the user explicitly asks "what do you remember about X?".',
+    '- When the user says "ignore memories" or "forget that" → proceed as if the memory store is empty for this session.',
+    '',
+    '**Drift caveat:** Memories are frozen at the time they were written.',
+    'Project structure, file paths, and code patterns may have changed since.',
+    'Always treat recalled memories as *hints*, not ground truth — verify against current code before acting.',
+    '',
+    '</when_to_access>',
+];
+/** How much to trust recalled memories. */
+export const TRUSTING_RECALL_SECTION = [
+    '<trusting_recall>',
+    '',
+    '- Before recommending a file or function mentioned in a memory, verify it still exists (e.g. read/ls).',
+    '- Grep for named entities (components, routes, config keys) before asserting they are present.',
+    '- Memory summaries are frozen in time — treat file:line citations as approximate, not authoritative.',
+    '- When a memory conflicts with what you observe in the codebase, trust the codebase.',
+    '',
+    '</trusting_recall>',
+];

package/dist/resources/extensions/remote-questions/config.js

@@ -2,7 +2,7 @@
  * Remote Questions — configuration resolution and validation
  */
 import { AuthStorage } from "@gsd/pi-coding-agent";
-import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { loadEffectivePreferences } from "../shared/preferences.js";
 const ENV_KEYS = {
     slack: "SLACK_BOT_TOKEN",
     discord: "DISCORD_BOT_TOKEN",
@@ -59,7 +59,7 @@ function hydrateRemoteTokensFromAuth() {
 }
 export function resolveRemoteConfig() {
     hydrateRemoteTokensFromAuth();
-    const prefs = loadEffectiveGSDPreferences();
+    const prefs = loadEffectivePreferences();
     const rq = prefs?.preferences.remote_questions;
     if (!rq || !rq.channel || !rq.channel_id)
         return null;
@@ -83,7 +83,7 @@ export function resolveRemoteConfig() {
 }
 export function getRemoteConfigStatus() {
     hydrateRemoteTokensFromAuth();
-    const prefs = loadEffectiveGSDPreferences();
+    const prefs = loadEffectivePreferences();
     const rq = prefs?.preferences.remote_questions;
     if (!rq || !rq.channel || !rq.channel_id)
         return "Remote questions: not configured";

package/dist/resources/extensions/remote-questions/extension-manifest.json

@@ -6,6 +6,6 @@
   "tier": "bundled",
   "requires": { "platform": ">=2.29.0" },
   "provides": {
-    "commands": ["remote"]
+    "commands": ["remote", "lsd"]
   }
 }

package/dist/resources/extensions/remote-questions/index.js

@@ -0,0 +1,53 @@
+import { handleRemote } from "./remote-command.js";
+import { TelegramLiveRelay } from "./telegram-live-relay.js";
+function showLsdUsage(ctx) {
+    ctx.ui.notify([
+        "LSD remote questions:",
+        "  /lsd remote",
+        "  /lsd remote slack",
+        "  /lsd remote discord",
+        "  /lsd remote telegram",
+        "  /lsd remote status",
+        "  /lsd remote disconnect",
+        "",
+        "Telegram live relay:",
+        "  /lsd telegram connect",
+        "  /lsd telegram status",
+        "  /lsd telegram disconnect",
+    ].join("\n"), "info");
+}
+export default function RemoteQuestionsExtension(pi) {
+    const relay = new TelegramLiveRelay(pi);
+    pi.on("message_end", (event) => relay.onMessageEnd(event));
+    pi.on("tool_execution_start", (event) => relay.onToolExecutionStart(event));
+    pi.on("tool_execution_end", (event) => relay.onToolExecutionEnd(event));
+    pi.on("session_switch", async (event) => relay.onSessionSwitch(event));
+    pi.on("session_fork", async (event) => relay.onSessionFork(event));
+    pi.on("session_shutdown", async (event) => relay.onSessionShutdown(event));
+    pi.on("session_before_compact", (event) => relay.onSessionBeforeCompact(event));
+    pi.registerCommand("remote", {
+        description: "Configure remote questions (Slack, Discord, Telegram)",
+        handler: async (args, ctx) => {
+            await handleRemote(args, ctx, pi);
+        },
+    });
+    pi.registerCommand("lsd", {
+        description: "LSD command alias for remote questions",
+        handler: async (args, ctx) => {
+            const trimmed = args.trim();
+            if (trimmed === "" || trimmed === "help") {
+                showLsdUsage(ctx);
+                return;
+            }
+            if (await relay.handleLsdTelegram(trimmed, ctx)) {
+                return;
+            }
+            if (trimmed === "remote" || trimmed.startsWith("remote ")) {
+                await handleRemote(trimmed.replace(/^remote\s*/, "").trim(), ctx, pi);
+                return;
+            }
+            ctx.ui.notify(`Unknown /lsd subcommand: ${trimmed}`, "warning");
+            showLsdUsage(ctx);
+        },
+    });
+}

package/dist/resources/extensions/remote-questions/remote-command.js

@@ -5,7 +5,8 @@ import { AuthStorage } from "@gsd/pi-coding-agent";
 import { Editor, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { getGlobalPreferencesPath, loadEffectivePreferences } from "../shared/preferences.js";
+import { saveRemoteQuestionsConfig } from "../shared/remote-questions-config.js";
 import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
 import { maskEditorLine, sanitizeError } from "../shared/mod.js";
 import { getLatestPromptSummary } from "./status.js";
@@ -197,7 +198,7 @@ async function handleRemoteStatus(ctx) {
     ctx.ui.notify(lines.join("\n"), "info");
 }
 async function handleDisconnect(ctx) {
-    const prefs = loadEffectiveGSDPreferences();
+    const prefs = loadEffectivePreferences();
     const channel = prefs?.preferences.remote_questions?.channel;
     if (!channel)
         return void ctx.ui.notify("No remote channel configured — nothing to disconnect.", "info");
@@ -303,32 +304,8 @@ function removeProviderToken(provider) {
     const auth = getAuthStorage();
     auth.remove(provider);
 }
-export function saveRemoteQuestionsConfig(channel, channelId) {
-    const prefsPath = getGlobalGSDPreferencesPath();
-    const block = [
-        "remote_questions:",
-        `  channel: ${channel}`,
-        `  channel_id: \"${channelId}\"`,
-        "  timeout_minutes: 5",
-        "  poll_interval_seconds: 5",
-    ].join("\n");
-    const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    let next = content;
-    if (fmMatch) {
-        let frontmatter = fmMatch[1];
-        const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;
-        frontmatter = regex.test(frontmatter) ? frontmatter.replace(regex, block) : `${frontmatter.trimEnd()}\n${block}`;
-        next = `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}`;
-    }
-    else {
-        next = `---\n${block}\n---\n\n${content}`;
-    }
-    mkdirSync(dirname(prefsPath), { recursive: true });
-    writeFileSync(prefsPath, next, "utf-8");
-}
 function removeRemoteQuestionsConfig() {
-    const prefsPath = getGlobalGSDPreferencesPath();
+    const prefsPath = getGlobalPreferencesPath();
     if (!existsSync(prefsPath))
         return;
     const content = readFileSync(prefsPath, "utf-8");

package/dist/resources/extensions/remote-questions/telegram-adapter.js

@@ -1,19 +1,22 @@
 /**
  * Remote Questions — Telegram adapter
  */
+import { randomUUID } from "node:crypto";
 import { formatForTelegram, parseTelegramResponse } from "./format.js";
 import { apiRequest } from "./http-client.js";
+import { telegramPullUpdates } from "./telegram-update-stream.js";
 const TELEGRAM_API = "https://api.telegram.org";
 export class TelegramAdapter {
     name = "telegram";
     botUserId = null;
-    lastUpdateId = 0;
     lastSentText = "";
     token;
     chatId;
+    consumerId;
     constructor(token, chatId) {
         this.token = token;
         this.chatId = chatId;
+        this.consumerId = `remote-questions:${randomUUID()}`;
     }
     async validate() {
         const res = await this.telegramApi("getMe");
@@ -51,18 +54,8 @@ export class TelegramAdapter {
     async pollAnswer(prompt, ref) {
         if (!this.botUserId)
             await this.validate();
-        const res = await this.telegramApi("getUpdates", {
-            offset: this.lastUpdateId + 1,
-            timeout: 0,
-            allowed_updates: ["message", "callback_query"],
-        });
-        if (!res.ok || !Array.isArray(res.result))
-            return null;
-        for (const update of res.result) {
-            // Advance offset for all updates to prevent reprocessing
-            if (update.update_id > this.lastUpdateId) {
-                this.lastUpdateId = update.update_id;
-            }
+        const updates = await telegramPullUpdates(this.token, this.consumerId, ["message", "callback_query"]);
+        for (const update of updates) {
             // Handle callback_query (inline keyboard button press)
             if (update.callback_query) {
                 const cq = update.callback_query;