local-agent-memory 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,3 +1,109 @@
-# Temporary Holding Version
+# local-agent-memory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**local-agent-memory** es una herramienta de indexación de memoria para agentes de IA que opera localmente en tus repositorios. Permite sincronizar documentos Markdown, llevar un registro de sesiones de codificación y exponer toda esta información a asistentes virtuales e IDEs a través del protocolo **Model Context Protocol (MCP)**. Además, aprovecha bases de datos SQLite con FTS5 (búsqueda de texto completo) y modelos vectoriales ONNX para potentes búsquedas semánticas.
+
+---
+
+## Instalación
+
+Puedes instalar este paquete de forma global usando npm, lo cual te dará acceso a los binarios `memory` y `memory-mcp`.
+
+```bash
+npm install -g local-agent-memory
+```
+
+---
+
+## Funcionalidades y Comandos Principales (`memory`)
+
+Una vez instalado, tienes a tu disposición el CLI `memory` con los siguientes comandos para gestionar la memoria de tus proyectos:
+
+### 1. `init`
+Inicializa el entorno de memoria en el repositorio actual. Esto crea las bases de datos SQLite locales y configura las estructuras necesarias en una carpeta oculta (`.memory`).
+
+**Opciones:**
+- `-f, --force`: Fuerza la inicialización incluso si el proyecto ya fue inicializado.
+- `-r, --rules <rules>`: Inyecta reglas específicas para tu IDE (opciones: `cursor`, `claude`, `copilot`, `antigravity-ide`, `antigravity-cli`, `all`).
+- `-d, --docs <path>`: Ruta opcional a un directorio de documentación existente para mapearlo/indexarlo automáticamente.
+
+```bash
+memory init --rules all --docs ./docs
+```
+
+### 2. `sync`
+Sincroniza los archivos Markdown del proyecto en el índice de memoria local. Escanea los documentos y actualiza la base de datos para que los agentes cuenten con el contexto más reciente.
+
+```bash
+memory sync
+```
+
+### 3. `status`
+Comprueba el estado de sincronización del proyecto de memoria actual, mostrando detalles sobre archivos indexados y pendienetes.
+
+```bash
+memory status
+```
+
+### 4. `reindex` (o `prune`)
+Reconstruye los índices FTS (texto completo) y vectoriales desde cero. Útil si sospechas que hay corrupción o desincronización en la base de datos local.
+
+```bash
+memory reindex
+# o
+memory prune
+```
+
+### 5. `record-session`
+Registra un resumen de tu sesión de trabajo actual en el "ledger" (libro mayor) de memoria, documentando las tareas completadas y el contexto para retomarlo más adelante.
+
+**Opciones:**
+- `-s, --summary <summary>`: Define el texto del resumen del trabajo realizado.
+
+```bash
+memory record-session -s "Implementación del comando sync y corrección de bugs en SQLite"
+```
+
+### 6. `install-hook`
+Instala ganchos de Git (Git hooks) en tu repositorio local para recordar automáticamente a los desarrolladores registrar sesiones al hacer commits, o para automatizar el registro.
+
+```bash
+memory install-hook
+```
+
+### 7. `template <action>`
+Gestiona las plantillas de memoria (permite listar, crear o exportar plantillas desde el proyecto).
+
+**Opciones:**
+- `-n, --name <name>`: El nombre de la plantilla a gestionar.
+
+```bash
+memory template create --name mi-plantilla
+```
+
+---
+
+## Integración de Agentes y Model Context Protocol (MCP)
+
+Para que tus agentes de IA (como Claude Desktop, Cursor o Antigravity) puedan acceder a esta memoria enriquecida, el paquete provee un servidor MCP incorporado. 
+
+### Configuración Automática (`memory mcp-setup`)
+Esta utilidad configura tu entorno global instalando los modelos ONNX y binarios SQLite necesarios y, de manera interactiva, modifica el archivo de configuración del cliente MCP seleccionado (Claude, Cursor, Antigravity) para apuntar automáticamente a `memory-mcp`.
+
+```bash
+memory mcp-setup
+```
+
+### Ejecución Manual del Servidor (`memory-mcp`)
+Levanta el servidor compatible con el Model Context Protocol a través de stdio. Normalmente no necesitas ejecutar este comando directamente; los clientes como Claude Desktop o Cursor lo lanzan de forma transparente utilizando su archivo de configuración interno.
+
+```bash
+memory-mcp
+```
+
+*(Si configuras MCP manualmente, deberás establecer que tu cliente ejecute `memory-mcp` sin argumentos extra)*
+
+---
+
+## Licencia
+
+Este proyecto está bajo la licencia **ISC**.

package/dist/cli/commands/hook.d.ts

@@ -0,0 +1 @@
+export declare function installGitHook(): Promise<void>;

package/dist/cli/commands/hook.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installGitHook = installGitHook;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ora_1 = __importDefault(require("ora"));
+async function installGitHook() {
+    const cwd = process.cwd();
+    const gitDir = node_path_1.default.join(cwd, ".git");
+    const hooksDir = node_path_1.default.join(gitDir, "hooks");
+    const spinner = (0, ora_1.default)("Installing Git hook...").start();
+    try {
+        if (!node_fs_1.default.existsSync(gitDir)) {
+            spinner.fail("No .git directory found. Initialize a git repository first.");
+            process.exit(1);
+        }
+        if (!node_fs_1.default.existsSync(hooksDir)) {
+            await node_fs_1.default.promises.mkdir(hooksDir, { recursive: true });
+        }
+        // A prepare-commit-msg hook that reminds the developer
+        const hookName = "prepare-commit-msg";
+        const hookPath = node_path_1.default.join(hooksDir, hookName);
+        const hookContent = `#!/bin/sh
+# local-agent-memory prepare-commit-msg hook
+
+# Add a reminder to the commit message template
+echo "" >> "$1"
+echo "# 🧠 Remember to update the local-agent-memory ledger if you made architectural changes." >> "$1"
+echo "# You can run: memory record-session --summary \\"..."\\"" >> "$1"
+`;
+        // Write file
+        await node_fs_1.default.promises.writeFile(hookPath, hookContent, { mode: 0o755 });
+        node_fs_1.default.chmodSync(hookPath, 0o755);
+        // Also a post-commit hook that optionally captures the commit msg as a session if wanted.
+        // For now, the prompt requested a prepare-commit-msg or pre-commit hook that reminds or updates the ledger.
+        // Given git hooks are usually headless, appending a reminder to prepare-commit-msg is the standard approach,
+        // or using a post-commit hook to execute the memory update automatically.
+        // Let's create a post-commit hook too, as a fallback passive memory strategy
+        const postHookName = "post-commit";
+        const postHookPath = node_path_1.default.join(hooksDir, postHookName);
+        const postHookContent = `#!/bin/sh
+# local-agent-memory post-commit hook
+# Automatically records a memory session for this commit.
+
+COMMIT_MSG=$(git log -1 --pretty=%B)
+
+# If memory CLI exists, run it
+if command -v memory >/dev/null 2>&1; then
+  memory record-session --summary "Commit: $COMMIT_MSG" > /dev/null 2>&1 &
+elif npx --no-install memory --version >/dev/null 2>&1; then
+  npx --no-install memory record-session --summary "Commit: $COMMIT_MSG" > /dev/null 2>&1 &
+fi
+`;
+        await node_fs_1.default.promises.writeFile(postHookPath, postHookContent, { mode: 0o755 });
+        node_fs_1.default.chmodSync(postHookPath, 0o755);
+        spinner.succeed(`Successfully installed git hooks (prepare-commit-msg, post-commit) to ensure memory consistency.`);
+    }
+    catch (err) {
+        spinner.fail("Failed to install Git hook.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,5 @@
+export declare function initProject(options?: {
+    force?: boolean;
+    rules?: string;
+    docs?: string;
+}): Promise<void>;

package/dist/cli/commands/init.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const project_1 = require("../../db/project");
+const registry_1 = require("../../db/registry");
+async function initProject(options = {}) {
+    const cwd = process.cwd();
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    const gitDir = node_path_1.default.join(cwd, ".git");
+    if (!node_fs_1.default.existsSync(gitDir)) {
+        console.warn("⚠️  No .git directory found. Automatic Git hooks cannot be installed yet.");
+        console.warn("   Run `git init` and then `memory install-hook` later.\n");
+    }
+    const spinner = (0, ora_1.default)("Initializing project...").start();
+    try {
+        if (node_fs_1.default.existsSync(memoryDir)) {
+            if (!options.force) {
+                spinner.fail("Project already initialized. Use --force to overwrite.");
+                process.exit(1);
+            }
+            else {
+                // If force, we just continue (or we might want to clear it, but prompt says "a menos que se use --force", meaning we can overwrite or just proceed)
+            }
+        }
+        else {
+            await node_fs_1.default.promises.mkdir(memoryDir, { recursive: true });
+        }
+        // Subdirectories
+        await node_fs_1.default.promises.mkdir(node_path_1.default.join(memoryDir, "decisions"), {
+            recursive: true,
+        });
+        await node_fs_1.default.promises.mkdir(node_path_1.default.join(memoryDir, "context"), {
+            recursive: true,
+        });
+        // UUID
+        const projectId = node_crypto_1.default.randomUUID();
+        // Config file
+        const configData = {
+            project_id: projectId,
+            created_at: new Date().toISOString(),
+            include_paths: [".memory"],
+        };
+        if (options.docs) {
+            configData.include_paths.push(options.docs);
+        }
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(memoryDir, "config.json"), JSON.stringify(configData, null, 2));
+        // Core markdown
+        const coreMd = `# Core Rules\n\nThis file contains the core behavior and rules for this project.\n`;
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(memoryDir, "core.md"), coreMd);
+        // Initialize local DB
+        const localDbPath = (0, project_1.getLocalDbPath)(cwd);
+        const localDb = (0, project_1.initLocalDb)(localDbPath);
+        await new Promise((resolve, reject) => {
+            localDb.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        // Global Registry
+        // Make sure global registry db is initialized
+        const registryDb = (0, registry_1.initRegistryDb)();
+        await new Promise((resolve, reject) => {
+            registryDb.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        await (0, registry_1.registerProject)(projectId, cwd);
+        // Inject agent instructions
+        const memoryInstructions = `
+<!-- local-agent-memory rules -->
+- Consulta la herramienta MCP \`search_memory\` antes de proponer cambios de arquitectura, interfaces o decisiones de diseño.
+- Utiliza \`log_decision\` cada vez que se adopte una convención de código, biblioteca o patrón técnico nuevo.
+- Utiliza la herramienta de sesión para resumir acuerdos antes de dar por terminada una tarea.
+`;
+        spinner.stop();
+        let tools = [];
+        const availableRules = {
+            cursor: ".cursorrules",
+            windsurf: ".windsurfrules",
+            copilot: ".github/copilot-instructions.md",
+            claude: "CLAUDE.md",
+            "antigravity-ide": ".agents/rules/memory.md",
+            "antigravity-cli": ".agents/rules/memory.md",
+        };
+        if (options.rules) {
+            if (options.rules.toLowerCase() === "all") {
+                tools = Array.from(new Set(Object.values(availableRules)));
+            }
+            else {
+                const rulesList = options.rules
+                    .split(",")
+                    .map((r) => r.trim().toLowerCase());
+                tools = Array.from(new Set(rulesList
+                    .map((r) => availableRules[r])
+                    .filter((r) => Boolean(r))));
+            }
+        }
+        else {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: "checkbox",
+                    name: "tools",
+                    message: "Select the IDEs/CLIs to generate or inject memory rules into:",
+                    choices: [
+                        { name: "Cursor (.cursorrules)", value: ".cursorrules" },
+                        { name: "Windsurf (.windsurfrules)", value: ".windsurfrules" },
+                        {
+                            name: "GitHub Copilot (.github/copilot-instructions.md)",
+                            value: ".github/copilot-instructions.md",
+                        },
+                        { name: "Claude Code (CLAUDE.md)", value: "CLAUDE.md" },
+                        {
+                            name: "Antigravity IDE / CLI (.agents/rules/memory.md)",
+                            value: ".agents/rules/memory.md",
+                        },
+                    ],
+                },
+            ]);
+            tools = answers.tools;
+        }
+        spinner.start("Finishing initialization...");
+        for (const file of tools) {
+            const filePath = node_path_1.default.join(cwd, file);
+            const dir = node_path_1.default.dirname(filePath);
+            if (!node_fs_1.default.existsSync(dir)) {
+                await node_fs_1.default.promises.mkdir(dir, { recursive: true });
+            }
+            if (node_fs_1.default.existsSync(filePath)) {
+                const content = await node_fs_1.default.promises.readFile(filePath, "utf8");
+                if (!content.includes("<!-- local-agent-memory rules -->")) {
+                    await node_fs_1.default.promises.appendFile(filePath, `\n${memoryInstructions}`);
+                }
+            }
+            else {
+                await node_fs_1.default.promises.writeFile(filePath, `${memoryInstructions.trim()}\n`);
+            }
+        }
+        spinner.succeed(`Project initialized successfully with ID: ${projectId}`);
+    }
+    catch (err) {
+        spinner.fail("Failed to initialize project.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/record.d.ts

@@ -0,0 +1,3 @@
+export declare function recordSession(options?: {
+    summary?: string;
+}): Promise<void>;

package/dist/cli/commands/record.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordSession = recordSession;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const middleware_1 = require("../../mcp/middleware");
+async function recordSession(options = {}) {
+    const cwd = process.cwd();
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    const ledgerDir = node_path_1.default.join(memoryDir, "ledger");
+    const dateObj = new Date();
+    const year = dateObj.getFullYear();
+    const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+    const day = String(dateObj.getDate()).padStart(2, "0");
+    const hours = String(dateObj.getHours()).padStart(2, "0");
+    const minutes = String(dateObj.getMinutes()).padStart(2, "0");
+    const seconds = String(dateObj.getSeconds()).padStart(2, "0");
+    const filename = `${year}-${month}-${day}-${hours}-${minutes}-${seconds}-session.md`;
+    const summariesPath = node_path_1.default.join(ledgerDir, filename);
+    if (!node_fs_1.default.existsSync(memoryDir)) {
+        console.error("No .memory directory found. Run `memory init` first.");
+        process.exit(1);
+    }
+    let summary = options.summary;
+    if (!summary) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "summary",
+                message: "Enter a summary of the work done in this session:",
+                validate: (input) => input.trim().length > 0 || "Summary cannot be empty",
+            },
+        ]);
+        summary = answers.summary;
+    }
+    const spinner = (0, ora_1.default)("Recording session summary...").start();
+    try {
+        if (!node_fs_1.default.existsSync(ledgerDir)) {
+            await node_fs_1.default.promises.mkdir(ledgerDir, { recursive: true });
+        }
+        const date = dateObj.toISOString();
+        const content = `\n## Session ended at ${date}\n\n${summary}\n\n---\n`;
+        await node_fs_1.default.promises.writeFile(summariesPath, content);
+        // Trigger sync
+        await (0, middleware_1.syncMiddleware)();
+        spinner.succeed(`Session summary recorded successfully in .memory/ledger/${filename}`);
+    }
+    catch (err) {
+        spinner.fail("Failed to record session summary.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/reindex.d.ts

@@ -0,0 +1 @@
+export declare function reindexProject(): Promise<void>;

package/dist/cli/commands/reindex.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reindexProject = reindexProject;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ora_1 = __importDefault(require("ora"));
+const project_1 = require("../../db/project");
+const sync_1 = require("./sync");
+async function reindexProject() {
+    const cwd = process.cwd();
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    if (!node_fs_1.default.existsSync(memoryDir)) {
+        console.error("Project not initialized. Run memory init first.");
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)("Reindexing project memory (this may take a while)...").start();
+    try {
+        const localDbPath = (0, project_1.getLocalDbPath)(cwd);
+        // Check if db exists, then delete to force complete reindex
+        if (node_fs_1.default.existsSync(localDbPath)) {
+            spinner.text = "Deleting corrupted or existing local index...";
+            node_fs_1.default.unlinkSync(localDbPath);
+            // Also delete the WAL and SHM files if they exist
+            if (node_fs_1.default.existsSync(`${localDbPath}-wal`))
+                node_fs_1.default.unlinkSync(`${localDbPath}-wal`);
+            if (node_fs_1.default.existsSync(`${localDbPath}-shm`))
+                node_fs_1.default.unlinkSync(`${localDbPath}-shm`);
+        }
+        spinner.text = "Rebuilding index from scratch...";
+        const { newCount } = await (0, sync_1.doSyncProject)(cwd);
+        spinner.succeed(`Reindex complete: ${newCount} files processed.`);
+    }
+    catch (err) {
+        spinner.fail("Reindex failed.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function projectStatus(): Promise<void>;

package/dist/cli/commands/status.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectStatus = projectStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ora_1 = __importDefault(require("ora"));
+const project_1 = require("../../db/project");
+const registry_1 = require("../../db/registry");
+const sync_1 = require("./sync");
+async function projectStatus() {
+    const cwd = process.cwd();
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    if (!node_fs_1.default.existsSync(memoryDir)) {
+        console.error("Project not initialized. Run memory init first.");
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)("Checking project status...").start();
+    try {
+        const localDbPath = (0, project_1.getLocalDbPath)(cwd);
+        // Check global registry
+        const projectId = await (0, registry_1.getProjectByPath)(cwd);
+        // Check db manifests
+        let manifests = [];
+        if (node_fs_1.default.existsSync(localDbPath)) {
+            manifests = await (0, project_1.getAllManifests)(localDbPath);
+        }
+        const manifestMap = new Map(manifests.map((m) => [m.file_path, m]));
+        const currentFiles = await getAllMarkdownFiles(memoryDir);
+        let newCount = 0;
+        let modCount = 0;
+        let delCount = 0;
+        let syncedCount = 0;
+        for (const file of currentFiles) {
+            const stats = await node_fs_1.default.promises.stat(file);
+            const mtime = stats.mtimeMs;
+            const relativePath = node_path_1.default.relative(cwd, file);
+            const existing = manifestMap.get(relativePath);
+            if (!existing) {
+                newCount++;
+            }
+            else if (existing.mtime !== mtime) {
+                // Hash check for modified
+                const sha256 = await (0, sync_1.computeSha256)(file);
+                if (sha256 !== existing.sha256) {
+                    modCount++;
+                }
+                else {
+                    syncedCount++;
+                }
+            }
+            else {
+                syncedCount++;
+            }
+            manifestMap.delete(relativePath);
+        }
+        delCount = manifestMap.size;
+        spinner.stop();
+        console.log(`\nProject ID: ${projectId || "Unknown (Not in global registry)"}`);
+        console.log(`Total MD files tracking: ${currentFiles.length}`);
+        console.log(`---------------------------------`);
+        console.log(`In sync: ${syncedCount}`);
+        console.log(`New (untracked): ${newCount}`);
+        console.log(`Modified (unsynced): ${modCount}`);
+        console.log(`Deleted (orphaned in db): ${delCount}`);
+        console.log(`\nRun \`memory sync\` to update index.`);
+    }
+    catch (err) {
+        spinner.fail("Status check failed.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}
+// Utility identical to sync, duplication for simplicity of module boundaries, or could be extracted
+async function getAllMarkdownFiles(dirPath, arrayOfFiles = []) {
+    const files = await node_fs_1.default.promises.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isDirectory()) {
+            arrayOfFiles = await getAllMarkdownFiles(node_path_1.default.join(dirPath, file.name), arrayOfFiles);
+        }
+        else if (file.name.endsWith(".md")) {
+            arrayOfFiles.push(node_path_1.default.join(dirPath, file.name));
+        }
+    }
+    return arrayOfFiles;
+}

package/dist/cli/commands/sync.d.ts

@@ -0,0 +1,8 @@
+export interface SyncResult {
+    newCount: number;
+    modCount: number;
+    delCount: number;
+}
+export declare function doSyncProject(cwd: string): Promise<SyncResult>;
+export declare function syncProject(): Promise<void>;
+export declare function computeSha256(filePath: string): Promise<string>;