@folterung/project-memory 0.1.0

package/packages/cli/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@project-memory/cli",
+  "version": "0.1.0",
+  "description": "Project Memory CLI — init, scaffold, deep-index, search",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mem": "bin/mem.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "npm run build && c8 node --test dist/",
+    "test:no-coverage": "npm run build && node --test dist/"
+  },
+  "c8": {
+    "exclude": ["**/*.test.js", "**/cli/index.js", "**/bin/**"],
+    "include": ["dist/**/*.js"],
+    "check-coverage": true,
+    "lines": 85,
+    "functions": 85,
+    "branches": 85,
+    "statements": 85,
+    "reporter": ["text", "lcov"],
+    "reports-dir": "coverage"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fast-glob": "^3.3.2",
+    "minimatch": "^9.0.3",
+    "js-yaml": "^4.1.0",
+    "chalk": "^5.3.0",
+    "dotenv": "^16.3.1",
+    "@qdrant/js-client-rest": "^1.9.0",
+    "chokidar": "^3.5.3"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "c8": "^9.1.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/cli/src/chunking/chunker.test.ts

@@ -0,0 +1,54 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { chunkFile } from "./chunker.js";
+import { getSchemaVersion } from "./hash.js";
+
+describe("chunker", () => {
+  it("chunkFile returns chunks with required metadata", () => {
+    const chunks = chunkFile("src/foo.ts", "const x = 1;\nconst y = 2;\n");
+    assert.ok(Array.isArray(chunks));
+    assert.ok(chunks.length >= 1);
+    for (const c of chunks) {
+      assert.strictEqual(typeof c.id, "string");
+      assert.strictEqual(typeof c.text, "string");
+      assert.strictEqual(c.metadata.path, "src/foo.ts");
+      assert.strictEqual(c.metadata.language, "typescript");
+      assert.strictEqual(c.metadata.kind, "code");
+      assert.strictEqual(c.metadata.schema_version, getSchemaVersion());
+      assert.ok(c.metadata.hash.length > 0);
+    }
+  });
+
+  it("chunkFile for config returns single chunk", () => {
+    const chunks = chunkFile("config.json", '{"a":1}');
+    assert.strictEqual(chunks.length, 1);
+    assert.strictEqual(chunks[0].metadata.kind, "config");
+    assert.strictEqual(chunks[0].text, '{"a":1}');
+  });
+
+  it("chunkFile for markdown chunks by heading", () => {
+    const content = "# Title\n\nPara 1.\n\n## Section\n\nPara 2.\n";
+    const chunks = chunkFile("doc.md", content);
+    assert.ok(chunks.length >= 1);
+    const hasDoc = chunks.some((c) => c.metadata.kind === "doc");
+    assert.ok(hasDoc);
+  });
+
+  it("chunkFile is deterministic for same input", () => {
+    const input = "same content\n";
+    const path = "src/same.ts";
+    const a = chunkFile(path, input);
+    const b = chunkFile(path, input);
+    assert.strictEqual(a.length, b.length);
+    for (let i = 0; i < a.length; i++) {
+      assert.strictEqual(a[i].id, b[i].id);
+      assert.strictEqual(a[i].metadata.hash, b[i].metadata.hash);
+    }
+  });
+
+  it("chunkFile infers test kind for .test. path", () => {
+    const chunks = chunkFile("src/foo.test.ts", "describe('x', () => {});");
+    assert.ok(chunks.length >= 1);
+    assert.strictEqual(chunks[0].metadata.kind, "test");
+  });
+});

package/packages/cli/src/chunking/chunker.ts

@@ -0,0 +1,151 @@
+import { createHash } from "node:crypto";
+import { hashFileContent, chunkIdFromParts, getSchemaVersion } from "./hash.js";
+import type { Chunk, ChunkKind } from "./types.js";
+import { getModuleFromPath, getLanguageFromPath } from "./types.js";
+
+const SOFT_MAX_LINES = 400;
+const MIN_LINES = 50;
+
+function inferKind(path: string, language: string): ChunkKind {
+  const lower = path.toLowerCase();
+  if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("__tests__")) return "test";
+  if (lower.endsWith(".md") || lower.endsWith(".mdx")) return "doc";
+  if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml")) return "config";
+  if (lower.includes("schema")) return "schema";
+  return "code";
+}
+
+function chunkByLineWindows(
+  path: string,
+  content: string,
+  fileHash: string,
+  kind: ChunkKind
+): Chunk[] {
+  const language = getLanguageFromPath(path);
+  const module = getModuleFromPath(path);
+  const lines = content.split(/\r?\n/);
+  const chunks: Chunk[] = [];
+  let start = 0;
+  let index = 0;
+  while (start < lines.length) {
+    const windowSize = Math.min(SOFT_MAX_LINES, lines.length - start);
+    const end = start + windowSize;
+    const windowLines = lines.slice(start, end);
+    const text = windowLines.join("\n");
+    const partHash = createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+    const part = `L${start}-${end}-${partHash}`;
+    const id = chunkIdFromParts(path, part, fileHash);
+    chunks.push({
+      id,
+      text,
+      metadata: {
+        path,
+        language,
+        module,
+        kind,
+        hash: fileHash,
+        schema_version: getSchemaVersion(),
+        startLine: start + 1,
+        endLine: end,
+      },
+    });
+    start = end;
+    index++;
+  }
+  return chunks;
+}
+
+function chunkMarkdownByHeadings(path: string, content: string, fileHash: string): Chunk[] {
+  const language = "markdown";
+  const module = getModuleFromPath(path);
+  const lines = content.split(/\r?\n/);
+  const chunks: Chunk[] = [];
+  let currentStart = 0;
+  let currentLines: string[] = [];
+  let headingLevel = 0;
+
+  function flush(symbol?: string, endLine?: number) {
+    if (currentLines.length === 0) return;
+    const text = currentLines.join("\n");
+    const partHash = createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+    const part = symbol ?? `H${currentStart}-${partHash}`;
+    const id = chunkIdFromParts(path, part, fileHash);
+    chunks.push({
+      id,
+      text,
+      metadata: {
+        path,
+        language,
+        symbol: symbol ?? undefined,
+        module,
+        kind: "doc",
+        hash: fileHash,
+        schema_version: getSchemaVersion(),
+        startLine: currentStart + 1,
+        endLine: endLine ?? currentStart + currentLines.length,
+      },
+    });
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].trim();
+      if (currentLines.length > 0) {
+        flush(headingLevel > 0 ? title : undefined, i);
+      }
+      currentStart = i;
+      currentLines = [line];
+      headingLevel = level;
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentLines.length > 0) {
+    flush(headingLevel > 0 ? undefined : "body", lines.length);
+  }
+
+  if (chunks.length === 0 && content.trim()) {
+    return chunkByLineWindows(path, content, fileHash, "doc");
+  }
+  return chunks;
+}
+
+function chunkConfigAsSingle(path: string, content: string, fileHash: string): Chunk[] {
+  const language = getLanguageFromPath(path);
+  const module = getModuleFromPath(path);
+  const part = "config";
+  const id = chunkIdFromParts(path, part, fileHash);
+  return [
+    {
+      id,
+      text: content,
+      metadata: {
+        path,
+        language,
+        module,
+        kind: "config",
+        hash: fileHash,
+        schema_version: getSchemaVersion(),
+        startLine: 1,
+        endLine: content.split(/\r?\n/).length,
+      },
+    },
+  ];
+}
+
+export function chunkFile(path: string, content: string): Chunk[] {
+  const fileHash = hashFileContent(content);
+  const language = getLanguageFromPath(path);
+  const kind = inferKind(path, language);
+
+  if (kind === "doc" && (path.endsWith(".md") || path.endsWith(".mdx"))) {
+    return chunkMarkdownByHeadings(path, content, fileHash);
+  }
+  if (kind === "config") {
+    return chunkConfigAsSingle(path, content, fileHash);
+  }
+  return chunkByLineWindows(path, content, fileHash, kind);
+}

package/packages/cli/src/chunking/hash.test.ts

@@ -0,0 +1,41 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { hashFileContent, chunkIdFromParts, getSchemaVersion } from "./hash.js";
+
+describe("chunking hash", () => {
+  it("hashFileContent is deterministic", () => {
+    const content = "hello\nworld\n";
+    const a = hashFileContent(content);
+    const b = hashFileContent(content);
+    assert.strictEqual(a, b);
+  });
+
+  it("hashFileContent normalizes CRLF to LF", () => {
+    const crlf = "a\r\nb\r\n";
+    const lf = "a\nb\n";
+    assert.strictEqual(hashFileContent(crlf), hashFileContent(lf));
+  });
+
+  it("hashFileContent differs for different content", () => {
+    const h1 = hashFileContent("foo");
+    const h2 = hashFileContent("bar");
+    assert.notStrictEqual(h1, h2);
+  });
+
+  it("chunkIdFromParts is deterministic", () => {
+    const id1 = chunkIdFromParts("src/a.ts", "L0-10-abc", "filehash123");
+    const id2 = chunkIdFromParts("src/a.ts", "L0-10-abc", "filehash123");
+    assert.strictEqual(id1, id2);
+  });
+
+  it("chunkIdFromParts returns 32-char hex", () => {
+    const id = chunkIdFromParts("p", "part", "hash");
+    assert.match(id, /^[a-f0-9]{32}$/);
+  });
+
+  it("getSchemaVersion returns number", () => {
+    const v = getSchemaVersion();
+    assert.strictEqual(typeof v, "number");
+    assert.ok(v >= 1);
+  });
+});

package/packages/cli/src/chunking/hash.ts

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+
+const SCHEMA_VERSION = 1;
+
+function normalizeContent(content: string): string {
+  return content.replace(/\r\n/g, "\n").trimEnd() + "\n";
+}
+
+export function hashFileContent(content: string): string {
+  const normalized = normalizeContent(content);
+  return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+
+export function getSchemaVersion(): number {
+  return SCHEMA_VERSION;
+}
+
+export function chunkIdFromParts(path: string, part: string, contentHash: string): string {
+  const combined = `${path}:${part}:${contentHash}`;
+  return createHash("sha256").update(combined, "utf8").digest("hex").slice(0, 32);
+}

package/packages/cli/src/chunking/types.test.ts

@@ -0,0 +1,28 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { getModuleFromPath, getLanguageFromPath } from "./types.js";
+
+describe("chunking types", () => {
+  it("getModuleFromPath returns dir for nested path", () => {
+    assert.strictEqual(getModuleFromPath("src/foo/bar.ts"), "src/foo");
+    assert.strictEqual(getModuleFromPath("a/b/c/d.js"), "a/b/c");
+  });
+
+  it("getModuleFromPath returns path for single segment", () => {
+    assert.strictEqual(getModuleFromPath("index.ts"), "index.ts");
+  });
+
+  it("getLanguageFromPath maps extensions", () => {
+    assert.strictEqual(getLanguageFromPath("file.ts"), "typescript");
+    assert.strictEqual(getLanguageFromPath("file.tsx"), "typescript");
+    assert.strictEqual(getLanguageFromPath("file.js"), "javascript");
+    assert.strictEqual(getLanguageFromPath("file.json"), "json");
+    assert.strictEqual(getLanguageFromPath("file.yaml"), "yaml");
+    assert.strictEqual(getLanguageFromPath("file.yml"), "yaml");
+    assert.strictEqual(getLanguageFromPath("file.md"), "markdown");
+  });
+
+  it("getLanguageFromPath returns ext for unknown", () => {
+    assert.strictEqual(getLanguageFromPath("file.xyz"), "xyz");
+  });
+});

package/packages/cli/src/chunking/types.ts

@@ -0,0 +1,43 @@
+export type ChunkKind = "code" | "doc" | "config" | "schema" | "test" | "system_map" | "module_summary" | "entrypoint";
+
+export interface ChunkMetadata {
+  path: string;
+  language: string;
+  symbol?: string;
+  module: string;
+  kind: ChunkKind;
+  hash: string;
+  schema_version: number;
+  startLine?: number;
+  endLine?: number;
+}
+
+export interface Chunk {
+  id: string;
+  text: string;
+  metadata: ChunkMetadata;
+}
+
+export function getModuleFromPath(path: string): string {
+  const parts = path.replace(/\\/g, "/").split("/");
+  if (parts.length <= 1) return path;
+  return parts.slice(0, -1).join("/");
+}
+
+export function getLanguageFromPath(path: string): string {
+  const ext = path.replace(/^.*\./, "").toLowerCase();
+  const map: Record<string, string> = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    md: "markdown",
+    mdx: "markdown",
+  };
+  return map[ext] ?? ext;
+}

package/packages/cli/src/cli/index.ts

@@ -0,0 +1,79 @@
+import { program } from "commander";
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+import { runInit } from "../commands/init.js";
+import { runScaffold } from "../commands/scaffold.js";
+import { runDown } from "../commands/down.js";
+import { runDoctor } from "../commands/doctor.js";
+import { runReset } from "../commands/reset.js";
+import { runDeepIndexCommand } from "../commands/deep-index.js";
+import { runUpdate } from "../commands/update.js";
+import { runWatch } from "../commands/watch.js";
+import { runQuery } from "../commands/query.js";
+import { runExplain } from "../commands/explain.js";
+
+const root = cwd();
+
+program
+  .name("mem")
+  .description("Project Memory — local-first project understanding for Cursor")
+  .version("0.1.0");
+
+program
+  .command("init")
+  .description("Create .mem/config.yml and .memignore")
+  .action(() => runInit(root));
+
+program
+  .command("scaffold")
+  .description("Phase 1: start Qdrant, apply scope+ignore, build index, start server")
+  .option("--include <globs...>", "Override indexing.include")
+  .option("--exclude <globs...>", "Override indexing.exclude")
+  .option("--write-config", "Persist include/exclude to .mem/config.yml")
+  .action(async (opts) => runScaffold(root));
+
+program
+  .command("down")
+  .description("Stop Docker Compose containers")
+  .action(() => runDown(root));
+
+program
+  .command("doctor")
+  .description("Check Docker, Qdrant, config, scope/ignore")
+  .action(async () => runDoctor(root));
+
+program
+  .command("reset")
+  .description("Wipe index state and deep-index progress")
+  .option("-v, --volumes", "Hint: use docker compose down -v to wipe volumes")
+  .action((opts) => runReset(root, { volumes: opts.volumes }));
+
+program
+  .command("deep-index")
+  .description("Phase 2: embed remaining chunks (resumable)")
+  .action(() => runDeepIndexCommand(root));
+
+program
+  .command("update")
+  .description("Incremental update: re-run Phase 1")
+  .action(() => runUpdate(root));
+
+program
+  .command("watch")
+  .description("Watch filesystem and run update on change")
+  .action(() => runWatch(root));
+
+program
+  .command("query <text>")
+  .description("Call server /search with text")
+  .action((text: string) => runQuery(root, text ?? ""));
+
+program
+  .command("explain <symbolOrPath>")
+  .description("Call server /explain for symbol or path")
+  .action((symbolOrPath: string) => runExplain(root, symbolOrPath ?? ""));
+
+export async function run(): Promise<void> {
+  await program.parseAsync();
+  if (!process.argv.slice(2).length) program.outputHelp();
+}

package/packages/cli/src/commands/deep-index.ts

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { configExists } from "../config/load.js";
+import { runDeepIndex } from "../phase2/deep-index.js";
+
+export async function runDeepIndexCommand(cwd: string): Promise<void> {
+  if (!configExists(cwd)) {
+    console.error(chalk.red("No config found. Run"), chalk.cyan("mem init"), chalk.red("then"), chalk.cyan("mem scaffold"), chalk.red("first."));
+    process.exit(1);
+  }
+  try {
+    await runDeepIndex(cwd);
+  } catch (err) {
+    console.error(chalk.red("Deep index failed:"), (err as Error).message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/doctor.ts

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+import { configExists, loadConfig } from "../config/load.js";
+import { checkDockerAvailable, checkQdrantHealthy } from "../docker/compose.js";
+
+export async function runDoctor(cwd: string): Promise<void> {
+  console.log(chalk.bold("Project Memory Doctor\n"));
+
+  const dockerOk = checkDockerAvailable(cwd);
+  console.log(dockerOk ? chalk.green("✓") : chalk.red("✗"), "Docker Compose available");
+  if (!dockerOk) {
+    console.log(chalk.dim("  Install Docker and Docker Compose."));
+  }
+
+  const qdrantOk = await checkQdrantHealthy();
+  console.log(qdrantOk ? chalk.green("✓") : chalk.yellow("○"), "Qdrant healthy (localhost:6333)");
+  if (!qdrantOk) {
+    console.log(chalk.dim("  Run mem scaffold to start Qdrant."));
+  }
+
+  const hasConfig = configExists(cwd);
+  console.log(hasConfig ? chalk.green("✓") : chalk.yellow("○"), "Config present (.mem/config.yml)");
+  if (!hasConfig) {
+    console.log(chalk.dim("  Run mem init first."));
+  }
+
+  if (hasConfig) {
+    const config = loadConfig(cwd);
+    console.log(chalk.green("✓"), "Scope:", config.indexing?.include?.length ? config.indexing.include.join(", ") : "entire repo");
+  }
+
+  console.log();
+}

package/packages/cli/src/commands/down.ts

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+import { dockerComposeDown } from "../docker/compose.js";
+
+export function runDown(cwd: string): void {
+  try {
+    dockerComposeDown(cwd);
+    console.log(chalk.green("Containers stopped."));
+  } catch (err) {
+    console.error(chalk.red("Failed to stop containers:"), (err as Error).message);
+    throw err;
+  }
+}

package/packages/cli/src/commands/explain.ts

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+
+const DEFAULT_SERVER_URL = "http://127.0.0.1:31415";
+
+export async function runExplain(_cwd: string, symbolOrPath: string): Promise<void> {
+  const baseUrl = process.env.MEM_SERVER_URL ?? DEFAULT_SERVER_URL;
+  try {
+    const res = await fetch(`${baseUrl}/explain/${encodeURIComponent(symbolOrPath)}`);
+    if (!res.ok) {
+      console.error(chalk.red("Explain failed:"), res.status);
+      process.exit(1);
+    }
+    const data = (await res.json()) as { symbol: string; snippet: string; path?: string };
+    console.log(chalk.bold(data.symbol));
+    if (data.path) console.log(chalk.dim("Path:"), data.path);
+    console.log("\n", data.snippet);
+  } catch (e) {
+    console.error(chalk.red("Request failed:"), (e as Error).message);
+    console.log(chalk.dim("Ensure memory server is running (mem scaffold)."));
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/init.ts

@@ -0,0 +1,37 @@
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { getDefaultConfigYaml, getDefaultMemignore } from "../config/defaults.js";
+import { CONFIG_DIR, CONFIG_FILE, MEMIGNORE_FILE } from "../config/types.js";
+
+export function runInit(cwd: string): void {
+  const configPath = join(cwd, CONFIG_FILE);
+  const memignorePath = join(cwd, MEMIGNORE_FILE);
+  const memDir = join(cwd, CONFIG_DIR);
+  const stateDir = join(memDir, "state");
+
+  if (!existsSync(memDir)) {
+    mkdirSync(memDir, { recursive: true });
+    console.log(chalk.green("Created"), CONFIG_DIR + "/");
+  }
+  if (!existsSync(stateDir)) {
+    mkdirSync(stateDir, { recursive: true });
+    console.log(chalk.green("Created"), CONFIG_DIR + "/state/");
+  }
+
+  if (!existsSync(configPath)) {
+    writeFileSync(configPath, getDefaultConfigYaml(), "utf8");
+    console.log(chalk.green("Created"), CONFIG_FILE);
+  } else {
+    console.log(chalk.dim("Config already exists:"), CONFIG_FILE);
+  }
+
+  if (!existsSync(memignorePath)) {
+    writeFileSync(memignorePath, getDefaultMemignore(), "utf8");
+    console.log(chalk.green("Created"), MEMIGNORE_FILE);
+  } else {
+    console.log(chalk.dim("Ignore file already exists:"), MEMIGNORE_FILE);
+  }
+
+  console.log(chalk.green("\nProject Memory initialized. Run"), chalk.cyan("mem scaffold"), chalk.green("to build the index."));
+}

package/packages/cli/src/commands/query.ts

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+
+const DEFAULT_SERVER_URL = "http://127.0.0.1:31415";
+
+async function search(query: string, limit: number, baseUrl: string): Promise<void> {
+  const res = await fetch(`${baseUrl}/search`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query, limit }),
+  });
+  if (!res.ok) {
+    console.error(chalk.red("Search failed:"), res.status, await res.text());
+    process.exit(1);
+  }
+  const data = (await res.json()) as {
+    systemMaps?: Array<{ text: string; path?: string }>;
+    moduleSummaries?: Array<{ text: string; path?: string }>;
+    chunks?: Array<{ text: string; path?: string; score?: number }>;
+  };
+  if (data.systemMaps?.length) {
+    console.log(chalk.bold("System maps"));
+    for (const sm of data.systemMaps.slice(0, 3)) {
+      console.log(chalk.dim(sm.path ?? ""), "\n", sm.text.slice(0, 200) + (sm.text.length > 200 ? "..." : ""), "\n");
+    }
+  }
+  if (data.moduleSummaries?.length) {
+    console.log(chalk.bold("Module summaries"));
+    for (const ms of data.moduleSummaries.slice(0, 5)) {
+      console.log(chalk.dim(ms.path ?? ""), "\n", ms.text.slice(0, 150) + (ms.text.length > 150 ? "..." : ""), "\n");
+    }
+  }
+  if (data.chunks?.length) {
+    console.log(chalk.bold("Chunks"));
+    for (const c of data.chunks.slice(0, 5)) {
+      console.log(chalk.dim(c.path ?? ""), c.score != null ? chalk.dim(`(${c.score})`) : "", "\n", c.text.slice(0, 200) + (c.text.length > 200 ? "..." : ""), "\n");
+    }
+  }
+}
+
+export async function runQuery(_cwd: string, text: string): Promise<void> {
+  const baseUrl = process.env.MEM_SERVER_URL ?? DEFAULT_SERVER_URL;
+  try {
+    await search(text, 15, baseUrl);
+  } catch (e) {
+    console.error(chalk.red("Request failed:"), (e as Error).message);
+    console.log(chalk.dim("Ensure memory server is running (mem scaffold)."));
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/reset.ts

@@ -0,0 +1,30 @@
+import { rmSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { DEEP_INDEX_STATE_FILE } from "../config/types.js";
+
+export function runReset(cwd: string, options: { volumes?: boolean } = {}): void {
+  const stateDir = join(cwd, ".mem", "state");
+  const deepIndexPath = join(cwd, DEEP_INDEX_STATE_FILE);
+
+  if (existsSync(deepIndexPath)) {
+    rmSync(deepIndexPath, { force: true });
+    console.log(chalk.green("Removed"), DEEP_INDEX_STATE_FILE);
+  }
+
+  if (existsSync(stateDir)) {
+    try {
+      const files = readdirSync(stateDir);
+      for (const f of files) {
+        rmSync(join(stateDir, f), { force: true });
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(chalk.green("Reset complete. Index state and deep-index progress cleared."));
+  if (options.volumes) {
+    console.log(chalk.dim("To wipe Qdrant volume, run: docker compose down -v"));
+  }
+}