@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/executors/lsp-client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Native LSP Client — uses vscode-jsonrpc for proper message framing.
+ *
+ * Same approach as Claude Code: createMessageConnection over stdio.
+ * Same configuration as Claude Code's LSP plugins.
+ * Supports: TypeScript, Python, Go, Rust, C/C++, Swift, Java, Kotlin, Lua, PHP, Ruby, C#.
+ */
+export interface LspServerConfig {
+    command: string;
+    args: string[];
+    extensionToLanguage: Record<string, string>;
+    startupTimeout: number;
+}
+export declare const LSP_SERVERS: Record<string, LspServerConfig>;
+export declare function getServerForFile(filePath: string): string | undefined;
+export declare function getLanguageId(filePath: string): string | undefined;
+export declare class LspServer {
+    private process;
+    private connection;
+    private initialized;
+    private openFiles;
+    private diagnosticsReceived;
+    readonly serverName: string;
+    readonly config: LspServerConfig;
+    private rootUri;
+    constructor(serverName: string, rootPath: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    openFile(filePath: string): Promise<void>;
+    definition(filePath: string, line: number, character: number): Promise<unknown>;
+    references(filePath: string, line: number, character: number): Promise<unknown>;
+    hover(filePath: string, line: number, character: number): Promise<unknown>;
+    documentSymbols(filePath: string): Promise<unknown>;
+    rename(filePath: string, line: number, character: number, newName: string): Promise<unknown>;
+    private ensureReady;
+}
+export declare function getOrCreateServer(serverName: string, rootPath: string): LspServer;
+export declare function shutdownAll(): Promise<void>;

package/dist-cjs/executors/lsp-client.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Native LSP Client — uses vscode-jsonrpc for proper message framing.
+ *
+ * Same approach as Claude Code: createMessageConnection over stdio.
+ * Same configuration as Claude Code's LSP plugins.
+ * Supports: TypeScript, Python, Go, Rust, C/C++, Swift, Java, Kotlin, Lua, PHP, Ruby, C#.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LspServer = exports.LSP_SERVERS = void 0;
+exports.getServerForFile = getServerForFile;
+exports.getLanguageId = getLanguageId;
+exports.getOrCreateServer = getOrCreateServer;
+exports.shutdownAll = shutdownAll;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const node_module_1 = require("node:module");
+let vscodeJsonrpc;
+// ESM module path for createRequire
+const __esmFilePath = (0, node_url_1.fileURLToPath)(import.meta.url);
+function getJsonRpc() {
+    if (!vscodeJsonrpc) {
+        vscodeJsonrpc = (0, node_module_1.createRequire)(__esmFilePath)("vscode-jsonrpc/node");
+    }
+    return vscodeJsonrpc;
+}
+exports.LSP_SERVERS = {
+    typescript: {
+        command: "typescript-language-server",
+        args: ["--stdio"],
+        extensionToLanguage: {
+            ".ts": "typescript",
+            ".tsx": "typescriptreact",
+            ".js": "javascript",
+            ".jsx": "javascriptreact",
+            ".mts": "typescript",
+            ".cts": "typescript",
+            ".mjs": "javascript",
+            ".cjs": "javascript",
+        },
+        startupTimeout: 30_000,
+    },
+    python: {
+        command: "pyright-langserver",
+        args: ["--stdio"],
+        extensionToLanguage: { ".py": "python", ".pyi": "python" },
+        startupTimeout: 60_000,
+    },
+    go: {
+        command: "gopls",
+        args: [],
+        extensionToLanguage: { ".go": "go" },
+        startupTimeout: 30_000,
+    },
+    rust: {
+        command: "rust-analyzer",
+        args: [],
+        extensionToLanguage: { ".rs": "rust" },
+        startupTimeout: 60_000,
+    },
+    "c/cpp": {
+        command: "clangd",
+        args: ["--background-index"],
+        extensionToLanguage: {
+            ".c": "c",
+            ".h": "c",
+            ".cpp": "cpp",
+            ".cc": "cpp",
+            ".cxx": "cpp",
+            ".hpp": "cpp",
+            ".hxx": "cpp",
+        },
+        startupTimeout: 30_000,
+    },
+    swift: {
+        command: "sourcekit-lsp",
+        args: [],
+        extensionToLanguage: { ".swift": "swift" },
+        startupTimeout: 30_000,
+    },
+    java: {
+        command: "jdtls",
+        args: [],
+        extensionToLanguage: { ".java": "java" },
+        startupTimeout: 120_000,
+    },
+    kotlin: {
+        command: "kotlin-language-server",
+        args: ["--stdio"],
+        extensionToLanguage: { ".kt": "kotlin", ".kts": "kotlin" },
+        startupTimeout: 120_000,
+    },
+    lua: {
+        command: "lua-language-server",
+        args: [],
+        extensionToLanguage: { ".lua": "lua" },
+        startupTimeout: 30_000,
+    },
+    php: {
+        command: "intelephense",
+        args: ["--stdio"],
+        extensionToLanguage: { ".php": "php" },
+        startupTimeout: 30_000,
+    },
+    ruby: {
+        command: "ruby-lsp",
+        args: [],
+        extensionToLanguage: { ".rb": "ruby", ".rake": "ruby", ".gemspec": "ruby" },
+        startupTimeout: 30_000,
+    },
+    csharp: {
+        command: "csharp-ls",
+        args: [],
+        extensionToLanguage: { ".cs": "csharp" },
+        startupTimeout: 30_000,
+    },
+};
+// Build reverse lookup: file extension → server name
+const EXT_TO_SERVER = new Map();
+for (const [serverName, config] of Object.entries(exports.LSP_SERVERS)) {
+    for (const ext of Object.keys(config.extensionToLanguage)) {
+        EXT_TO_SERVER.set(ext, serverName);
+    }
+}
+function getServerForFile(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    return EXT_TO_SERVER.get(ext);
+}
+function getLanguageId(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    const serverName = EXT_TO_SERVER.get(ext);
+    if (!serverName)
+        return undefined;
+    return exports.LSP_SERVERS[serverName]?.extensionToLanguage[ext];
+}
+// ---------------------------------------------------------------------------
+// LSP Server Instance — uses vscode-jsonrpc createMessageConnection
+// ---------------------------------------------------------------------------
+class LspServer {
+    process = null;
+    connection = null;
+    initialized = false;
+    openFiles = new Set();
+    diagnosticsReceived = new Set();
+    serverName;
+    config;
+    rootUri;
+    constructor(serverName, rootPath) {
+        this.serverName = serverName;
+        const cfg = exports.LSP_SERVERS[serverName];
+        if (!cfg)
+            throw new Error(`Unknown LSP server: ${serverName}`);
+        this.config = cfg;
+        this.rootUri = `file://${(0, node_path_1.resolve)(rootPath)}`;
+    }
+    async start() {
+        if (this.connection)
+            return;
+        this.process = (0, node_child_process_1.spawn)(this.config.command, this.config.args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stderr?.on("data", () => {
+            // Swallow stderr — language servers are noisy
+        });
+        this.process.on("exit", () => {
+            this.connection?.dispose();
+            this.connection = null;
+            this.process = null;
+            this.initialized = false;
+            this.openFiles.clear();
+            this.diagnosticsReceived.clear();
+        });
+        // Create vscode-jsonrpc connection — handles Content-Length framing,
+        // request/response matching, notification routing. Same as Claude Code.
+        const jsonrpc = getJsonRpc();
+        this.connection = jsonrpc.createMessageConnection(new jsonrpc.StreamMessageReader(this.process.stdout), new jsonrpc.StreamMessageWriter(this.process.stdin));
+        // Listen for diagnostics notifications (signals file analysis complete)
+        this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+            const p = params;
+            if (p.uri)
+                this.diagnosticsReceived.add(p.uri);
+        });
+        this.connection.listen();
+        // Initialize handshake
+        await this.connection.sendRequest("initialize", {
+            processId: globalThis.process.pid,
+            rootUri: this.rootUri,
+            capabilities: {
+                textDocument: {
+                    definition: { dynamicRegistration: false },
+                    references: { dynamicRegistration: false },
+                    hover: { dynamicRegistration: false, contentFormat: ["plaintext", "markdown"] },
+                    documentSymbol: { dynamicRegistration: false },
+                    rename: { dynamicRegistration: false, prepareSupport: false },
+                    publishDiagnostics: { relatedInformation: true },
+                },
+                workspace: {
+                    workspaceFolders: true,
+                },
+            },
+            workspaceFolders: [{ uri: this.rootUri, name: "root" }],
+        });
+        this.connection.sendNotification("initialized", {});
+        this.initialized = true;
+    }
+    async stop() {
+        if (!this.connection)
+            return;
+        try {
+            await this.connection.sendRequest("shutdown");
+            this.connection.sendNotification("exit");
+        }
+        catch {
+            // Force kill if graceful shutdown fails
+        }
+        this.connection.dispose();
+        this.connection = null;
+        this.process?.kill("SIGTERM");
+        this.process = null;
+        this.initialized = false;
+    }
+    // Ensure a file is opened in the language server
+    async openFile(filePath) {
+        const uri = `file://${(0, node_path_1.resolve)(filePath)}`;
+        if (this.openFiles.has(uri))
+            return;
+        const languageId = getLanguageId(filePath);
+        if (!languageId)
+            return;
+        let text;
+        try {
+            text = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(filePath), "utf-8");
+        }
+        catch {
+            return;
+        }
+        this.connection?.sendNotification("textDocument/didOpen", {
+            textDocument: { uri, languageId, version: 1, text },
+        });
+        this.openFiles.add(uri);
+        // No wait needed. LSP servers queue requests after didOpen and respond
+        // when ready. Tested: TypeScript responds to hover in 239ms with zero
+        // wait (before diagnostics arrive). Pyright responds after its analysis.
+        // The sendRequest in the caller will block until the server responds.
+    }
+    // --- LSP Operations ---
+    async definition(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/definition", {
+            textDocument: { uri: `file://${(0, node_path_1.resolve)(filePath)}` },
+            position: { line, character },
+        });
+    }
+    async references(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/references", {
+            textDocument: { uri: `file://${(0, node_path_1.resolve)(filePath)}` },
+            position: { line, character },
+            context: { includeDeclaration: true },
+        });
+    }
+    async hover(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/hover", {
+            textDocument: { uri: `file://${(0, node_path_1.resolve)(filePath)}` },
+            position: { line, character },
+        });
+    }
+    async documentSymbols(filePath) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/documentSymbol", {
+            textDocument: { uri: `file://${(0, node_path_1.resolve)(filePath)}` },
+        });
+    }
+    async rename(filePath, line, character, newName) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/rename", {
+            textDocument: { uri: `file://${(0, node_path_1.resolve)(filePath)}` },
+            position: { line, character },
+            newName,
+        });
+    }
+    // --- Internals ---
+    async ensureReady(filePath) {
+        if (!this.initialized)
+            await this.start();
+        await this.openFile(filePath);
+    }
+}
+exports.LspServer = LspServer;
+// ---------------------------------------------------------------------------
+// Server Pool — one server per language, shared across queries
+// ---------------------------------------------------------------------------
+const serverPool = new Map();
+function getOrCreateServer(serverName, rootPath) {
+    const key = `${serverName}:${rootPath}`;
+    let server = serverPool.get(key);
+    if (!server) {
+        server = new LspServer(serverName, rootPath);
+        serverPool.set(key, server);
+    }
+    return server;
+}
+async function shutdownAll() {
+    const stops = [...serverPool.values()].map((s) => s.stop());
+    await Promise.allSettled(stops);
+    serverPool.clear();
+}

package/dist-cjs/executors/memory.d.ts

@@ -0,0 +1,203 @@
+/**
+ * @aria/tools - Memory tool executors
+ *
+ * Implementation of memory operations for ARIA tool system.
+ * These executors integrate with Memoria for persistent memory management.
+ */
+import type { MemoryItem, ToolItem, SkillItem } from "@aria-cli/types";
+import type { ToolContext, ToolResult } from "../types.js";
+/**
+ * Typed shape for the `ctx.context` field used by memory executors.
+ * The runner populates this from conversation messages and system prompt sections.
+ * Memory executors cast `ctx.context as RecallToolContext` to access these fields.
+ *
+ * This avoids adding new top-level fields to ToolContext — uses the existing
+ * `context?: unknown` field instead.
+ */
+export interface RecallToolContext {
+    /** Last N conversation turns (role + truncated content) from the current session. */
+    conversationContext?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Pre-extracted system prompt sections for self-context queries. */
+    systemPromptSections?: Record<string, string>;
+}
+/**
+ * Get the last N turns from the current conversation.
+ * Reads from the RecallToolContext populated by the runner.
+ *
+ * @param messages - conversation messages from ctx.context.conversationContext
+ * @param args.turns - number of turns to return (default 5; 1 turn = 2 messages)
+ * @returns last N*2 messages (user+assistant pairs)
+ */
+export declare function getConversationContext(messages: Array<{
+    role: string;
+    content: string;
+}> | undefined, args: {
+    turns?: number;
+}): Array<{
+    role: string;
+    content: string;
+}>;
+type TranscriptMessage = {
+    role: string;
+    content: string;
+};
+/**
+ * Get transcript from a past session by reading Claude Code JSONL session files.
+ *
+ * Scans ~/.claude/projects/ for JSONL session files, parses user/assistant messages,
+ * and returns the last N turns from the most recent (or specified) session.
+ *
+ * Lightweight JSONL reader implemented directly in the tools package to avoid
+ * importing from @aria/memoria-bridge. Includes symlink safety checks and
+ * content truncation.
+ *
+ * @param args.sessionId - session ID (or partial path match) to retrieve (default: most recent)
+ * @param args.turns - number of turns to return (default 10; 1 turn = 2 messages)
+ * @returns array of {role, content} messages from the session
+ */
+export declare function getSessionTranscript(args: {
+    sessionId?: string;
+    turns?: number;
+}): Promise<TranscriptMessage[]>;
+/** Valid self-context section names that map to system prompt headings. */
+export type SelfContextSection = "memory" | "strategies" | "profile" | "context";
+/**
+ * Read a section of the agent's own system prompt.
+ * This is a NO-DB-QUERY primitive — the data was already extracted from the
+ * system prompt at session start and stored in RecallToolContext.systemPromptSections.
+ *
+ * Sections:
+ * - "memory": observations, current-task, suggested-response (from ## Memory)
+ * - "strategies": relevant procedures and behavioral rules (from ## Relevant Procedures)
+ * - "profile": user info (from ## What I know about...)
+ * - "context": background memories recalled at session start (from ## Background Context)
+ *
+ * @param sections - pre-extracted system prompt sections from RecallToolContext
+ * @param args.section - which section to retrieve
+ * @returns the section content, or null if section is unknown or not present
+ */
+export declare function getSelfContext(sections: Record<string, string> | undefined, args: {
+    section: string;
+}): string | null;
+export interface RememberInput {
+    /** Content to store in memory */
+    content: string;
+    /** Optional importance score (0.0-1.0) */
+    importance?: number;
+}
+export interface RememberOutput {
+    /** ID of the stored memory */
+    id: string;
+}
+/**
+ * Store content in Memoria with optional importance.
+ */
+export declare function executeRemember(input: RememberInput, ctx: ToolContext): Promise<ToolResult>;
+export interface RecallInput {
+    /** Query to search memories */
+    query: string;
+    /** Direct memory ID lookup (from [mem:id] progressive disclosure format) */
+    id?: string;
+    /** Maximum number of results (default: 10) */
+    limit?: number;
+    /** Optional tags to filter memories by */
+    tags?: string[];
+    /** ISO 8601 date string for temporal query — returns memories valid at this date */
+    date?: string;
+}
+export interface RecallOutput {
+    /** Retrieved memories */
+    memories: MemoryItem[];
+    /** Total count of returned memories */
+    count: number;
+    /** Formatted context string from APR (when available) */
+    formattedContext?: string;
+    /** Classified intent type from APR (when available) */
+    intent?: string;
+    /** Per-index source statistics from APR (when available) */
+    sourceStats?: Record<string, number>;
+    /** UCR planner reasoning (when available) */
+    planReasoning?: string;
+    /** UCR primitive results from non-memory sources (when available) */
+    primitiveResults?: Array<{
+        source: string;
+        data: unknown;
+    }>;
+}
+/**
+ * Retrieve memories by query from Memoria.
+ *
+ * Uses recallWithAPR when available to capture formattedContext,
+ * intent, and sourceStats metadata. Falls back to plain recall() with
+ * reranking + diversity options for backward compatibility.
+ */
+export declare function executeRecall(input: RecallInput, ctx: ToolContext): Promise<ToolResult>;
+export interface ForgetInput {
+    /** ID of the memory to delete */
+    id: string;
+}
+export interface ForgetOutput {
+    /** Whether the memory was deleted */
+    deleted: boolean;
+    /** ID of the memory that was requested to be deleted */
+    id: string;
+}
+/**
+ * Delete a memory by ID from Memoria.
+ */
+export declare function executeForget(input: ForgetInput, ctx: ToolContext): Promise<ToolResult>;
+export interface DiscoverInput {
+    /** Topic to search for */
+    topic: string;
+    /** Maximum number of items to retrieve (default: 10) */
+    limit?: number;
+    /** Kind of items to filter by (tool, skill) */
+    kind?: "tool" | "skill";
+}
+export interface DiscoverOutput {
+    /** Retrieved tool items */
+    tools: ToolItem[];
+    /** Retrieved skill items */
+    skills: SkillItem[];
+    /** Number of tools found */
+    toolCount: number;
+    /** Number of skills found */
+    skillCount: number;
+    /** Generated insights based on the results */
+    insights: string[];
+}
+/**
+ * Discover tools and skills by topic.
+ *
+ * Calls recallTools() and recallSkills() on Memoria directly,
+ * returning separate arrays (no merging or conversion needed).
+ * When input.kind is set, only the relevant API is called.
+ */
+export declare function executeDiscover(input: DiscoverInput, ctx: ToolContext): Promise<ToolResult>;
+export interface ReflectInput {
+    /** Summary of what happened in the conversation — what you did, what worked, what didn't */
+    summary: string;
+}
+export interface ReflectOutput {
+    /** Whether anything genuinely new was learned */
+    learned: boolean;
+    /** The observation stored, if any */
+    observation: string | null;
+    /** Skill candidate discovered during the conversation, if any */
+    skillCandidate?: {
+        name: string;
+        level: string;
+        description: string;
+    } | null;
+}
+/**
+ * Trigger self-reflection on the current conversation.
+ * Calls the router to identify genuine learnings (limitations,
+ * non-obvious strategies, user preferences, blind spots).
+ * Stores observations to the beliefs network when found.
+ */
+export declare function executeReflect(input: ReflectInput, ctx: ToolContext): Promise<ToolResult>;
+export {};