@lapis-notes/ai 0.1.0

package/dist/bootstrap/build.d.ts

@@ -0,0 +1,15 @@
+import type { AgentBootstrap, AgentBootstrapSkill, AgentBootstrapTool } from "./types";
+export interface BuildAgentBootstrapInput {
+    conversationId?: string;
+    scopeDir: string;
+    launchNotePath?: string;
+    workspaceLabel?: string;
+    tools?: readonly AgentBootstrapTool[];
+    skills?: readonly AgentBootstrapSkill[];
+    readText?: (path: string) => Promise<string | undefined>;
+}
+export declare function buildAgentBootstrap(input: BuildAgentBootstrapInput): Promise<AgentBootstrap>;
+export declare function buildSessionBootstrap(input: BuildAgentBootstrapInput): Promise<{
+    bootstrap: AgentBootstrap;
+    text: string;
+}>;

package/dist/bootstrap/build.js

@@ -0,0 +1,28 @@
+import { LAPIS_BOOTSTRAP_INSTRUCTIONS } from "./instructions";
+import { readAncestorFolderInstructions } from "./folder-instructions";
+import { formatSessionBootstrap } from "./format";
+export async function buildAgentBootstrap(input) {
+    const folderInstructions = input.readText
+        ? await readAncestorFolderInstructions(input.readText, input.scopeDir)
+        : [];
+    return {
+        application: { name: "Lapis Notes" },
+        conversation: {
+            id: input.conversationId,
+            scopeDir: input.scopeDir,
+            launchNotePath: input.launchNotePath,
+        },
+        workspace: input.workspaceLabel
+            ? { label: input.workspaceLabel }
+            : undefined,
+        tools: [...(input.tools ?? [])],
+        skills: [...(input.skills ?? [])],
+        folderInstructions,
+        instructions: [...LAPIS_BOOTSTRAP_INSTRUCTIONS],
+        truncated: folderInstructions.some((entry) => entry.truncated),
+    };
+}
+export async function buildSessionBootstrap(input) {
+    const bootstrap = await buildAgentBootstrap(input);
+    return { bootstrap, text: formatSessionBootstrap(bootstrap) };
+}

package/dist/bootstrap/folder-instructions.d.ts

@@ -0,0 +1,4 @@
+import { type FolderInstruction } from "./types";
+export declare function ancestorScopeDirs(scopeDir: string): string[];
+export declare function folderInstructionPath(scopeDir: string): string;
+export declare function readAncestorFolderInstructions(readText: (path: string) => Promise<string | undefined>, scopeDir: string): Promise<FolderInstruction[]>;

package/dist/bootstrap/folder-instructions.js

@@ -0,0 +1,49 @@
+import { hasHostFilesystemPath } from "../skills/manifest";
+import { FOLDER_INSTRUCTION_FILE, MAX_FOLDER_INSTRUCTION_CHARS, MAX_FOLDER_INSTRUCTION_TOTAL_CHARS, } from "./types";
+export function ancestorScopeDirs(scopeDir) {
+    const segments = scopeDir.split("/").filter(Boolean);
+    const dirs = [""];
+    for (let index = 0; index < segments.length; index += 1) {
+        dirs.push(segments.slice(0, index + 1).join("/"));
+    }
+    return dirs;
+}
+export function folderInstructionPath(scopeDir) {
+    return scopeDir
+        ? `${scopeDir}/.lapis/${FOLDER_INSTRUCTION_FILE}`
+        : `.lapis/${FOLDER_INSTRUCTION_FILE}`;
+}
+export async function readAncestorFolderInstructions(readText, scopeDir) {
+    const collected = [];
+    let remaining = MAX_FOLDER_INSTRUCTION_TOTAL_CHARS;
+    for (const dir of ancestorScopeDirs(scopeDir)) {
+        const path = folderInstructionPath(dir);
+        const raw = (await readText(path))?.replaceAll("\r\n", "\n");
+        if (raw == null || !raw.trim())
+            continue;
+        if (hasHostFilesystemPath(raw)) {
+            collected.push({
+                path,
+                text: "",
+                truncated: false,
+                omitted: "path-bearing",
+            });
+            continue;
+        }
+        let text = raw.trim();
+        let truncated = false;
+        if (text.length > MAX_FOLDER_INSTRUCTION_CHARS) {
+            text = text.slice(0, MAX_FOLDER_INSTRUCTION_CHARS);
+            truncated = true;
+        }
+        if (text.length > remaining) {
+            text = text.slice(0, Math.max(0, remaining));
+            truncated = true;
+        }
+        remaining -= text.length;
+        collected.push({ path, text, truncated });
+        if (remaining <= 0)
+            break;
+    }
+    return collected;
+}

package/dist/bootstrap/format.d.ts

@@ -0,0 +1,2 @@
+import type { AgentBootstrap } from "./types";
+export declare function formatSessionBootstrap(bootstrap: AgentBootstrap): string;

package/dist/bootstrap/format.js

@@ -0,0 +1,46 @@
+import { hasHostFilesystemPath } from "../skills/manifest";
+export function formatSessionBootstrap(bootstrap) {
+    const tools = bootstrap.tools.length > 0
+        ? bootstrap.tools
+            .map((tool) => `- ${tool.name} — ${oneLine(tool.description)}`)
+            .join("\n")
+        : "(none)";
+    const skills = bootstrap.skills.length > 0
+        ? bootstrap.skills.map((skill) => `- ${skill.name}`).join("\n")
+        : "(none)";
+    const folder = bootstrap.folderInstructions
+        .filter((entry) => !entry.omitted && entry.text.trim())
+        .map((entry) => `--- ${entry.path} ---\n${entry.text}`)
+        .join("\n\n");
+    const body = [
+        "<lapis_context>",
+        bootstrap.instructions.join("\n\n"),
+        "",
+        `Current scope: ${portableBootstrapPath(bootstrap.conversation.scopeDir, "(vault root)")}`,
+        `Launched from: ${portableBootstrapPath(bootstrap.conversation.launchNotePath, "(none)")}`,
+        `Workspace: ${bootstrap.workspace?.label?.trim() || "(none)"}`,
+        "",
+        "Available application tools:",
+        tools,
+        "",
+        "Available skills:",
+        skills,
+        ...(folder ? ["", "Folder instructions:", folder] : []),
+        "</lapis_context>",
+    ].join("\n");
+    if (hasHostFilesystemPath(body)) {
+        throw new Error("Session bootstrap must not include host filesystem paths.");
+    }
+    return body;
+}
+function portableBootstrapPath(value, empty) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return empty;
+    if (hasHostFilesystemPath(trimmed))
+        return "(application folder)";
+    return trimmed;
+}
+function oneLine(value) {
+    return value.replace(/\s+/gu, " ").trim();
+}

package/dist/bootstrap/instructions.d.ts

@@ -0,0 +1 @@
+export declare const LAPIS_BOOTSTRAP_INSTRUCTIONS: readonly string[];

package/dist/bootstrap/instructions.js

@@ -0,0 +1,8 @@
+export const LAPIS_BOOTSTRAP_INSTRUCTIONS = [
+    "You are operating as an AI assistant inside Lapis Notes.",
+    "Use application-provided tools when interacting with notes. Use note search tools when the user asks you to find, remember, locate, compare, or research information in their notes.",
+    "Do not manually inspect application storage when an equivalent Lapis tool exists.",
+    "The host controls your accessible note scope. Treat the supplied scope as authoritative.",
+    "Skills describe repeatable workflows. When a relevant skill is available, load its instructions with skills_read before following that workflow.",
+    "Keep note operations scoped to the current conversation unless the user explicitly requests a broader scope and the host permits it.",
+];

package/dist/bootstrap/types.d.ts

@@ -0,0 +1,36 @@
+export declare const FOLDER_INSTRUCTION_FILE = "AGENTS.md";
+export declare const MAX_FOLDER_INSTRUCTION_CHARS = 10000;
+export declare const MAX_FOLDER_INSTRUCTION_TOTAL_CHARS = 25000;
+export interface AgentBootstrapTool {
+    name: string;
+    description: string;
+}
+export interface AgentBootstrapSkill {
+    name: string;
+    description: string;
+    version: string;
+}
+export interface FolderInstruction {
+    path: string;
+    text: string;
+    truncated: boolean;
+    omitted?: "path-bearing";
+}
+export interface AgentBootstrap {
+    application: {
+        name: "Lapis Notes";
+    };
+    conversation: {
+        id?: string;
+        scopeDir: string;
+        launchNotePath?: string;
+    };
+    workspace?: {
+        label?: string;
+    };
+    tools: AgentBootstrapTool[];
+    skills: AgentBootstrapSkill[];
+    folderInstructions: FolderInstruction[];
+    instructions: string[];
+    truncated: boolean;
+}

package/dist/bootstrap/types.js

@@ -0,0 +1,3 @@
+export const FOLDER_INSTRUCTION_FILE = "AGENTS.md";
+export const MAX_FOLDER_INSTRUCTION_CHARS = 10_000;
+export const MAX_FOLDER_INSTRUCTION_TOTAL_CHARS = 25_000;