memoryblock 0.1.4 → 0.1.5

package/README.md

@@ -37,149 +37,107 @@
 
 </div>
 
-Memoryblock lets you deploy AI agents as isolated **blocks** - independent workspaces, each with their own memory, tools, and personality. Think of a block as a private office for an AI. Give it a job, point it at a channel, and let it run.
+`memoryblock` is a lightweight framework for orchestrating isolated AI background workers. Instead of building monolithic chatbots, we provision local workspaces called **blocks**. Each block acts as a dedicated environment equipped with its own continuous memory, toolset, and execution loop.
 
-One block can be your personal assistant. Another can monitor your infrastructure. A third can research topics and write summaries. They don't interfere with each other, they don't share memory, and they don't waste tokens re-learning what they already know.
+Spawn a devops block to watch your infrastructure, a research block to scrape web data, and your primary home block to coordinate tasks. No state pollution, no crossed context boundaries.
 
-Need them to collaborate? A block can spawn sub-agents, the temporary workers in sandboxed environments to handle specific tasks and report back. No shared state pollution, no context confusion.
-
-```
-you ─── terminal ──── block "home"       (your daily assistant)
-    ├── channel ───── block "devops"     (monitors + alerts)
-    └── web ui ────── block "research"   (deep dives + summaries)
-```
-
-## ✨ What Makes This Different
-
-### It's cheap to run. Seriously.
-
-Most AI tools send the entire tool schema. Thousands of tokens. On *every single message*. For a background agent running all day, that's money on fire.
-
-Memoryblock was engineered around this problem:
-
-- **On-demand schema loading** - tool definitions are injected only when needed, then dropped. Payload sizes go from ~2,600 tokens to ~1,200 tokens per turn.
-- **History trimming** - large tool outputs (log dumps, file contents) are read once, then truncated in memory to 500 characters. The LLM already saw it. No need to pay for it again.
-- **Smart context recovery** - when context fills up, the engine summarizes everything into clean, actionable notes and starts fresh. No crash, no data loss, no compact context error loops.
-
-> In testing, these optimizations reduce token growth between turns from 4.2× to under 2×, resulting in over 50% cost reduction on sustained sessions.
-
-### It runs on Bun. Nothing else.
-
-No Node.js. No Electron. No heavy frameworks. The entire core, HTTP server, WebSocket streaming, static file serving, is built on native APIs. Cold starts are fast. Memory usage is small.
-
-### Every block is its own world.
-
-Each block gets its own `config.json`, `memory.md`, `monitor.md`, `costs.json`, and log directory. Move a block between machines by copying its folder. Back it up by zipping it. There's no shared database, no centralized state, no magic.
-
-### Talk to it from anywhere.
-
-Your blocks are accessible through the **CLI** (a simple interactive terminal), different **Channels** (including Telegram, Discord, Slack, and more), and a **Web Dashboard** (with live WebSocket updates). Same block, same memory, different surfaces.
-
-### Use any model you want.
-
-Memoryblock doesn't lock you into one provider. Swap models per-block, per-task, or per-agent:
-
-| Adapter | Auth |
-|:---|:---|
-| **AWS Bedrock** | AWS credentials |
-| **OpenAI** | API key |
-| **Google Gemini** | API key |
-| **Anthropic** | API key |
-
-Adding a new adapter is one file. See [adapter docs](https://docs.memoryblock.io/adapters/) for examples.
+* **Absolute Isolation**: Every agent lives inside a dedicated filesystem directory (`config.json`, `memory.md`, `logs/`). To move an agent to a new server, you just copy its folder. No centralized databases to manage.
+* **Token Pruning**: Running background agents is historically expensive. `memoryblock` mitigates this by lazy-loading tool schemas only when invoked, and proactively truncating long tool outputs once analyzed. This typically halves the cost of sustained sessions.
+* **Native & Lean**: Zero dependency on heavy Node.js runtimes or Electron ecosystems. The core engine, HTTP server, and WebSocket router rely purely on [Bun's](https://bun.sh) native primitives for maximal I/O speed and minimal RAM overhead.
+* **Model Agnostic**: Provision blocks dynamically utilizing native definitions for OpenAI, Anthropic, AWS Bedrock, or Google Gemini.
 
 ## Quick Start
 
-Memoryblock is built natively for [Bun](https://bun.sh) for maximum performance, but we package a smart installer so you can get started using whatever you already have!
-
-### 1. Install memoryblock
-
-**- Option A: Bun (Recommended)**  
-If you already use Bun, this is the absolute fastest way to install:
-```bash
-bun install -g memoryblock
-```
+`memoryblock` leverages Bun under the hood for native execution speed. If you use npm, we automatically manage the local Bun environment for you.
 
-**- Option B: Node.js / NPM**
+**Install the framework globally:**
 ```bash
-npm install -g memoryblock
+bun install -g memoryblock     # Option A: Fastest
+npm install -g memoryblock     # Option B: Managed internally
 ```
 
-### 2. Setup your ecosystem
-Run the setup wizard to verify your local environment and enter your initial provider API keys:
+**Initialize your environment:**
 ```bash
 mblk init
 ```
+*This interactive wizard verifies your local environment and configures your initial LLM provider credentials.*
 
-### 3. Deploy your first block
-That's it! You can now start your very first personal assistant block:
+**Start your default block:**
 ```bash
-mblk start home
+mblk start [block-name]
 ```
+*Your autonomous assistant is now running in the background.*
 
-### Web Dashboard
+## Working with Channels
 
+Your blocks are decoupled from the UI. Communicate with them via the terminal, secure web dashboard, or standard chat clients. 
+
+**Launch the Web Dashboard:**
 ```bash
 mblk web
 ```
+*Access real-time stream logs, cost tracking, and memory management at `localhost:8420`.*
 
-Opens a live dashboard at `localhost:8420` with real-time block monitoring, cost tracking, and memory inspection.
-
-### Channels
-
+**Route a block to social channels:**
 ```bash
 mblk start home --channel telegram
 ```
+*Securely interact with your existing agent state from anywhere without losing active history.*
 
-Your block is now live on the channel you chose. Same memory, same tools, accessible from anywhere.
-
-## Commands
+## Command Reference
 
-Everything you can do from the terminal, you can do from chat (and soon, the web UI too):
-
-| CLI | In-Chat | What it does |
-|:---|:---|:---|
-| `mblk create <name>` | `/create-block <name>` | Create a new block |
-| `mblk start <block>` | — | Start a block's monitor |
-| `mblk stop <block>` | — | Stop a running monitor |
-| `mblk status` | `/status` | Show all blocks and their state |
-| `mblk delete <block>` | — | Archive a block safely |
-| `mblk restore <archive>` | — | Restore from archive |
-| `mblk reset <block>` | — | Reset memory and costs |
-| `mblk add <plugin>` | — | Install a plugin |
-
-Full reference: [command docs](https://docs.memoryblock.io/commands.md)
+| Command | Description |
+|:---|:---|
+| `mblk init` | Interactive setup - configure credentials and create your first block |
+| `mblk create <name>` | Create a new block (isolated AI workspace) |
+| `mblk start [block]` | Start a block's monitor loop (or all blocks) |
+| `mblk stop [block]` | Stop a running block monitor (or all blocks) |
+| `mblk status` | Show all blocks and their state |
+| `mblk delete <block>` | Archive a block safely (use `--hard` to permanently delete) |
+| `mblk restore <name>` | Restore an archived block |
+| `mblk reset <block>` | Reset memory, costs, and session (use `--hard` to wipe identity) |
+| `mblk permissions <block>` | View or update block permissions |
+| `mblk settings [plugin]` | View or edit plugin settings |
+| `mblk add [plugin]` | Install a plugin (no args lists available) |
+| `mblk remove <plugin>` | Remove an installed plugin |
+| `mblk server start` | Start the web UI and API server |
+| `mblk server stop` | Stop the running server |
+| `mblk server status` | Show server status |
+| `mblk server token` | View or regenerate the API auth token |
+| `mblk service install` | Register memoryblock to start on boot/login |
+| `mblk shutdown` | Stop all blocks and the server |
+| `mblk restart` | Full restart — shutdown then start everything as daemons |
+
+Full reference: [command docs](https://docs.memoryblock.io/commands/)
 
 ## Plugins
 
 Blocks come with a core set of tools. Need more? Add them:
 
 ```bash
-mblk add web-search    # search the web
-mblk add fetch-webpage # extract text from any URL
-mblk add agents        # multi-agent orchestration
+mblk add web-search    # Enables high-fidelity SERP querying
+mblk add fetch-webpage # Extracts and chunks text from structured URLs
+mblk add agents        # Allows blocks to spawn ephemeral sub-agents
 ```
 
-Plugins are just npm packages. The installer resolves, downloads, and wires them in automatically.
-
-| Plugin | What it does |
-|:---|:---|
-| `web-search` | Search the web with your configured provider |
-| `fetch-webpage` | Extract clean text from URLs |
-| `agents` | Spawn sub-agents for delegated tasks |
-| `aws` | Cloud SDK code generation tools |
+Adapters for **OpenAI, Anthropic, Google Gemini, and AWS Bedrock** are natively supported out-of-the-box. Adding a custom provider adapter requires implementing a single unified payload interface.
 
-## Adapters
+## Monorepo Architecture
 
-Each adapter is a single file that maps Memoryblock's internal message format to a provider's API. They handle authentication, request formatting, and response parsing. Writing a new adapter is straightforward — the interface is small and well-documented.
+`memoryblock` is built as a highly modular TypeScript monorepo utilizing a strict one-way Directed Acyclic Graph (DAG) for dependency management. All sub-packages are independently publishable.
 
-See all supported adapters and how to write your own: [adapters](https://docs.memoryblock.io/adapters/)
-
-## Channels
-
-Channels are how your blocks talk to the outside world. The CLI, messaging platforms, and the web dashboard are all channels — equal citizens, not afterthoughts. Adding a new channel is a single file implementation.
-
-Supported and upcoming channels are documented in [channels](https://docs.memoryblock.io/channels/).
+| Package | Responsibility |
+|:---|:---|
+| `memoryblock` | Global executable wrapper, setup tooling, and CLI orchestration. |
+| `@memoryblock/core` | Extracted engine runtime (Gatekeeper, Memory Manager, Monitor loops). |
+| `@memoryblock/types` | Centralized Zod validation schemas and TypeScript interfaces. |
+| `@memoryblock/daemon` | Low-level OS process spawner and background lifecycle manager. |
+| `@memoryblock/adapters` | Unified REST/SDK implementations for LLM providers. |
+| `@memoryblock/channels` | Transport layer for CLI, WebSockets, and messaging platforms. |
+| `@memoryblock/tools` | Core functional schemas (File I/O, OS interactions). |
+| `@memoryblock/api` | Fast, dependency-injected HTTP web server integration. |
+| `@memoryblock/locale` | Formatting tools and centralized translation strings. |
+| `@memoryblock/web` | Standalone UI distribution package. |
 
 ## Community & Support
 
@@ -191,18 +149,18 @@ Supported and upcoming channels are documented in [channels](https://docs.memory
 **memoryblock** is a highly modular system. Here are the official packages:
 
 **The Core**
-*   [**memoryblock**](https://www.npmjs.com/package/memoryblock) - The core engine interface and types.
-*   [**@memoryblock/daemon**](https://www.npmjs.com/package/@memoryblock/daemon) - Background daemon manager.
-*   [**@memoryblock/api**](https://www.npmjs.com/package/@memoryblock/api) - Core REST and WebSocket API server.
-*   [**@memoryblock/cli**](https://www.npmjs.com/package/@memoryblock/cli) - Command-line interface.
-*   [**@memoryblock/types**](https://www.npmjs.com/package/@memoryblock/types) - Core TypeScript definitions and schemas.
+*   [**memoryblock**](https://www.npmjs.com/package/memoryblock) - CLI orchestrator and command routing.
+*   [**@memoryblock/core**](https://www.npmjs.com/package/@memoryblock/core) - Engine runtime, memory manager, gatekeeper.
+*   [**@memoryblock/types**](https://www.npmjs.com/package/@memoryblock/types) - Shared TypeScript definitions and schemas.
+*   [**@memoryblock/locale**](https://www.npmjs.com/package/@memoryblock/locale) - Localization strings and utilities.
 
 **Integrations & Tooling**
-*   [**@memoryblock/adapters**](https://www.npmjs.com/package/@memoryblock/adapters) - LLM adapters (OpenAI, Anthropic, Bedrock, etc).
+*   [**@memoryblock/adapters**](https://www.npmjs.com/package/@memoryblock/adapters) - LLM provider adapters (OpenAI, Anthropic, Bedrock, etc).
 *   [**@memoryblock/channels**](https://www.npmjs.com/package/@memoryblock/channels) - Communication channels (CLI, Telegram, Web).
-*   [**@memoryblock/tools**](https://www.npmjs.com/package/@memoryblock/tools) - Standard tool definitions and schemas.
-*   [**@memoryblock/locale**](https://www.npmjs.com/package/@memoryblock/locale) - Localization strings and formatting.
-*   [**@memoryblock/web**](https://www.npmjs.com/package/@memoryblock/web) - Front-end dashboard and Web UI.
+*   [**@memoryblock/tools**](https://www.npmjs.com/package/@memoryblock/tools) - Tool registry and built-in definitions.
+*   [**@memoryblock/daemon**](https://www.npmjs.com/package/@memoryblock/daemon) - Background process spawner and manager.
+*   [**@memoryblock/api**](https://www.npmjs.com/package/@memoryblock/api) - HTTP/WebSocket API server.
+*   [**@memoryblock/web**](https://www.npmjs.com/package/@memoryblock/web) - Front-end dashboard static files.
 
 **Plugins**
 *   [**@memoryblock/plugin-installer**](https://www.npmjs.com/package/@memoryblock/plugin-installer) - Plugin installer and registry manager.

package/bin/mblk.js

@@ -1,88 +1,85 @@
 #!/usr/bin/env node
+
 /**
- * memoryblock - Auto-Bootstrap CLI Wrapper
- * 
- * Ensures the end-user has a flawless zero-configuration setup.
- * Automatically checks and installs Bun (the high-performance runtime) 
- * and the @memoryblock/cli ecosystem tools if they are missing.
+ * memoryblock CLI — Universal Entry Point
+ *
+ * This is the bin proxy installed by `npm install -g memoryblock`.
+ * It ensures Bun is available (auto-installing if needed), then re-executes
+ * itself under Bun for optimal performance.
+ *
+ * If Bun is already the runtime, we skip the proxy and run the CLI directly.
+ *
+ * Design:
+ *   npm install -g memoryblock  →  symlinks `mblk` to this file
+ *   User runs `mblk start`     →  this script detects Node, installs bun, re-execs via bun
+ *   Subsequent runs             →  bun is found immediately, re-exec is instant
  */
-const { execSync, spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-// Helper to silently run commands
-const run = (cmd) => {
-    try {
-        return execSync(cmd, { stdio: 'pipe' }).toString().trim();
-    } catch {
-        return null;
-    }
-};
 
-const localBun = path.join(os.homedir(), '.bun', 'bin', 'bun');
-const bunGlobalRoot = path.join(os.homedir(), '.bun', 'install', 'global', 'node_modules');
-const cliScriptBun = path.join(bunGlobalRoot, '@memoryblock/cli', 'bin', 'mblk.js');
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
 
-// 0ms Fast-Path: If everything is already installed natively, skip ALL slow checks!
-if (fs.existsSync(localBun) && fs.existsSync(cliScriptBun)) {
-    const result = spawnSync(localBun, [cliScriptBun, ...process.argv.slice(2)], { stdio: 'inherit' });
-    process.exit(result.status ?? 1);
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-// Check package managers (Slow Path)
-let bunPath = run('command -v bun');
-const hasNpm = !!run('command -v npm');
-const hasBunFn = !!run('command -v bun');
+// ─── Step 0: Are we already running under Bun? ──────────────────────
+// If yes, skip the proxy and run the CLI entry point directly.
+const isBun = typeof globalThis.Bun !== 'undefined';
 
-// 1. Install Bun if completely missing
-if (!hasBunFn && !fs.existsSync(localBun)) {
-    console.log('\n⚡ \x1b[1mmemoryblock\x1b[0m is powered by \x1b[33mBun\x1b[0m for extreme performance.');
-    console.log('   Installing the lightweight engine automatically...\n');
+if (isBun) {
+    // Running under Bun — load the compiled CLI entry point
+    // This file is at:   packages/memoryblock/bin/mblk.js
+    // Entry point is at: packages/memoryblock/dist/entry.js
+    const entryPath = join(__dirname, '..', 'dist', 'entry.js');
     try {
-        execSync('curl -fsSL https://bun.sh/install | bash', { stdio: 'inherit' });
-        bunPath = localBun;
-        console.log('\n✅ Bun installed successfully!');
-    } catch (e) {
-        console.error('\n❌ Failed to automatically install Bun. Please run: curl -fsSL https://bun.sh/install | bash');
+        await import(entryPath);
+    } catch (err) {
+        console.error('❌ Failed to load memoryblock CLI.');
+        console.error('   This usually means the package was not built correctly.');
+        console.error('   Try reinstalling: npm install -g memoryblock');
+        if (err && typeof err === 'object' && 'message' in err) {
+            console.error(`\n   Error: ${err.message}`);
+        }
         process.exit(1);
     }
-}
-if (!bunPath) bunPath = localBun;
+} else {
+    // ─── Step 1: Running under Node.js — find or install Bun ─────────
+    const localBun = join(homedir(), '.bun', 'bin', 'bun');
 
-// 2. Identify global path & manager
-const npmGlobalRoot = hasNpm ? run('npm root -g') : null;
-let cliScript = cliScriptBun;
+    const findBun = () => {
+        try {
+            return execSync('command -v bun', { stdio: 'pipe' }).toString().trim();
+        } catch {
+            return null;
+        }
+    };
 
-// 3. Install @memoryblock/cli if missing
-// (We also gracefully check if NPM already downloaded it first so we don't redownload)
-if (!fs.existsSync(cliScript) && npmGlobalRoot) {
-    const npmScript = path.join(npmGlobalRoot, '@memoryblock/cli', 'bin', 'mblk.js');
-    if (fs.existsSync(npmScript)) cliScript = npmScript;
-}
+    let bunPath = findBun();
 
-if (!fs.existsSync(cliScript)) {
-    console.log('\n📦 Downloading memoryblock terminal interface tools...\n');
-    try {
-        execSync(`${bunPath} install -g @memoryblock/cli@latest`, { stdio: 'inherit' });
-        cliScript = path.join(bunGlobalRoot, '@memoryblock/cli', 'bin', 'mblk.js');
-    } catch (e) {
-        if (hasNpm) {
-            console.log('\n⚠️ Bun global install tripped. Falling back to NPM...\n');
-            try {
-                execSync('npm install -g @memoryblock/cli@latest', { stdio: 'inherit' });
-                cliScript = path.join(npmGlobalRoot, '@memoryblock/cli', 'bin', 'mblk.js');
-            } catch (err) {
-                console.error('\n❌ Failed to sync @memoryblock/cli. Please run manually: npm install -g @memoryblock/cli');
-                process.exit(1);
-            }
-        } else {
-            console.error(`\n❌ Failed to sync @memoryblock/cli. Please run manually: ${bunPath} install -g @memoryblock/cli`);
+    if (!bunPath && !existsSync(localBun)) {
+        console.log('\n⚡ \x1b[1mmemoryblock\x1b[0m is powered by \x1b[33mBun\x1b[0m for extreme performance.');
+        console.log('   Installing the lightweight engine automatically...\n');
+        try {
+            execSync('curl -fsSL https://bun.sh/install | bash', { stdio: 'inherit' });
+            bunPath = localBun;
+            console.log('\n✅ Bun installed successfully!\n');
+        } catch {
+            console.error('\n❌ Failed to install Bun automatically.');
+            console.error('   Please install manually: curl -fsSL https://bun.sh/install | bash');
             process.exit(1);
         }
     }
-}
 
-// 4. Hand-off execution seamlessly to Bun, passing all CLI arguments
-const result = spawnSync(bunPath, [cliScript, ...process.argv.slice(2)], { stdio: 'inherit' });
-process.exit(result.status ?? 1);
+    if (!bunPath) bunPath = localBun;
+
+    // ─── Step 2: Re-execute this same file under Bun ─────────────────
+    // Bun will detect itself as the runtime and take the fast path above.
+    const result = spawnSync(bunPath, [__filename, ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        env: { ...process.env, MEMORYBLOCK_BUN_PROXY: '1' },
+    });
+
+    process.exit(result.status ?? 1);
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,2 @@
+export declare function createCommand(blockName: string): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAYA,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDpE"}

package/dist/commands/create.js

@@ -0,0 +1,48 @@
+import { join } from 'node:path';
+import { ensureDir, writeJson, atomicWrite, pathExists } from '@memoryblock/core';
+import { loadGlobalConfig, resolveBlockPath, isInitialized, } from '@memoryblock/core';
+import { BlockConfigSchema, PulseStateSchema } from '@memoryblock/types';
+import { log } from '@memoryblock/core';
+import { FILE_TEMPLATES } from '@memoryblock/core';
+// Templates moved to prompts.ts
+export async function createCommand(blockName) {
+    if (!(await isInitialized())) {
+        throw new Error('Not initialized. Run `mblk init` first.');
+    }
+    if (!/^[a-z0-9][a-z0-9-]{0,31}$/.test(blockName)) {
+        throw new Error('Block name must start with a letter/number and contain only lowercase letters, numbers, and hyphens (max 32 chars).');
+    }
+    const globalConfig = await loadGlobalConfig();
+    const blockPath = resolveBlockPath(globalConfig, blockName);
+    if (await pathExists(blockPath)) {
+        throw new Error(`Block "${blockName}" already exists at ${blockPath}`);
+    }
+    log.brand(`Creating block: ${blockName}\n`);
+    // Directory structure
+    await ensureDir(blockPath);
+    await ensureDir(join(blockPath, 'agents'));
+    await ensureDir(join(blockPath, 'logs'));
+    // Block config (inherits global defaults)
+    const blockConfig = BlockConfigSchema.parse({
+        name: blockName,
+        adapter: globalConfig.defaults.adapter,
+        memory: globalConfig.defaults.memory,
+        pulse: globalConfig.defaults.pulse,
+    });
+    await writeJson(join(blockPath, 'config.json'), blockConfig);
+    log.success('Created config.json');
+    // Initial pulse state
+    const pulse = PulseStateSchema.parse({});
+    await writeJson(join(blockPath, 'pulse.json'), pulse);
+    log.success('Created pulse.json');
+    // Core identity files
+    await atomicWrite(join(blockPath, 'memory.md'), FILE_TEMPLATES.MEMORY_MD);
+    log.success('Created memory.md');
+    await atomicWrite(join(blockPath, 'monitor.md'), FILE_TEMPLATES.MONITOR_MD(blockName));
+    log.success('Created monitor.md');
+    console.log('');
+    log.brand(`Block "${blockName}" is ready.`);
+    log.dim(`  Path: ${blockPath}`);
+    log.dim(`  Start: mblk start ${blockName}`);
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,EACH,gBAAgB,EAAE,gBAAgB,EAAE,aAAa,GACpD,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,gCAAgC;AAEhC,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,SAAiB;IACjD,IAAI,CAAC,CAAC,MAAM,aAAa,EAAE,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC/D,CAAC;IAED,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,qHAAqH,CAAC,CAAC;IAC3I,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,gBAAgB,EAAE,CAAC;IAC9C,MAAM,SAAS,GAAG,gBAAgB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IAE5D,IAAI,MAAM,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,UAAU,SAAS,uBAAuB,SAAS,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,GAAG,CAAC,KAAK,CAAC,mBAAmB,SAAS,IAAI,CAAC,CAAC;IAE5C,sBAAsB;IACtB,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC;IAC3B,MAAM,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3C,MAAM,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAEzC,0CAA0C;IAC1C,MAAM,WAAW,GAAG,iBAAiB,CAAC,KAAK,CAAC;QACxC,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,YAAY,CAAC,QAAQ,CAAC,OAAO;QACtC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM;QACpC,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK;KACrC,CAAC,CAAC;IACH,MAAM,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,EAAE,WAAW,CAAC,CAAC;IAC7D,GAAG,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAEnC,sBAAsB;IACtB,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACzC,MAAM,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC;IACtD,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAElC,sBAAsB;IACtB,MAAM,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IAC1E,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEjC,MAAM,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;IACvF,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAElC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,GAAG,CAAC,KAAK,CAAC,UAAU,SAAS,aAAa,CAAC,CAAC;IAC5C,GAAG,CAAC,GAAG,CAAC,WAAW,SAAS,EAAE,CAAC,CAAC;IAChC,GAAG,CAAC,GAAG,CAAC,uBAAuB,SAAS,EAAE,CAAC,CAAC;AAChD,CAAC"}

package/dist/commands/delete.d.ts

@@ -0,0 +1,5 @@
+export declare function deleteCommand(blockName: string, options?: {
+    hard?: boolean;
+}): Promise<void>;
+export declare function restoreCommand(archiveName: string): Promise<void>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../src/commands/delete.ts"],"names":[],"mappings":"AA6DA,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmElG;AAED,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCvE"}

package/dist/commands/delete.js

@@ -0,0 +1,147 @@
+import { join } from 'node:path';
+import { promises as fsp } from 'node:fs';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadGlobalConfig, resolveBlocksDir, isInitialized } from '@memoryblock/core';
+import { ensureDir, pathExists } from '@memoryblock/core';
+import { log } from '@memoryblock/core';
+import { t } from '@memoryblock/locale';
+/**
+ * Find archived folders matching a block name.
+ * Supports both:
+ *   - Exact archive name: "dev-pal_2026-03-21T10-33-24-242Z"
+ *   - Block name prefix: "dev-pal" (matches all archives of that block)
+ */
+async function findArchives(archiveDir, query) {
+    // Strip _archive/ prefix if user pastes it
+    const name = query.replace(/^_archive\//, '');
+    try {
+        const entries = await fsp.readdir(archiveDir);
+        // 1. Exact match
+        if (entries.includes(name))
+            return [name];
+        // 2. Prefix match: "dev-pal" matches "dev-pal_2026-03-21T10-33-24-242Z"
+        const matches = entries
+            .filter(e => e.startsWith(`${name}_`))
+            .sort()
+            .reverse(); // newest first
+        return matches;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Resolve a single archive — if multiple exist, let user pick.
+ */
+async function resolveArchive(archiveDir, query) {
+    const matches = await findArchives(archiveDir, query);
+    if (matches.length === 0)
+        return null;
+    if (matches.length === 1)
+        return matches[0];
+    // Multiple archives — let the user pick
+    const selection = await p.select({
+        message: `Multiple archives found for "${query}". Which one?`,
+        options: matches.map(m => {
+            // Extract the timestamp for a cleaner label
+            const tsMatch = m.match(/_(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/);
+            const hint = tsMatch ? tsMatch[1].replace(/-/g, ':').replace('T', ' ').slice(0, 16) : '';
+            return { value: m, label: m, hint };
+        }),
+    });
+    if (p.isCancel(selection))
+        return null;
+    return selection;
+}
+export async function deleteCommand(blockName, options) {
+    if (!(await isInitialized())) {
+        throw new Error(t.general.notInitialized);
+    }
+    const globalConfig = await loadGlobalConfig();
+    const blocksDir = resolveBlocksDir(globalConfig);
+    const blockPath = join(blocksDir, blockName);
+    // Check if it's a direct block path first
+    if (await pathExists(blockPath)) {
+        if (blockName.startsWith('_archive/')) {
+            if (!options?.hard) {
+                throw new Error(t.archive.mustUseHard);
+            }
+        }
+        if (options?.hard) {
+            try {
+                await fsp.rm(blockPath, { recursive: true, force: true });
+                log.success(t.archive.hardDeleteSuccess(blockName));
+            }
+            catch (err) {
+                throw new Error(`Failed to delete: ${err.message}`);
+            }
+            return;
+        }
+        // Soft delete — move to _archive directory
+        const archiveDir = join(blocksDir, '_archive');
+        await ensureDir(archiveDir);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const archiveName = `${blockName}_${timestamp}`;
+        const archivePath = join(archiveDir, archiveName);
+        try {
+            await fsp.rename(blockPath, archivePath);
+            log.success(t.archive.success(blockName));
+            log.dim(`  ${t.archive.location(`_archive/${archiveName}`)}`);
+            log.dim(`  ${t.archive.restoreCmd(blockName)}`);
+            log.dim(`  ${t.archive.deleteCmd(blockName)}`);
+        }
+        catch (err) {
+            throw new Error(`Failed to archive block: ${err.message}`);
+        }
+        return;
+    }
+    // Not a live block — maybe user wants to hard-delete an archive by name?
+    if (options?.hard) {
+        const archiveDir = join(blocksDir, '_archive');
+        const resolved = await resolveArchive(archiveDir, blockName);
+        if (!resolved) {
+            throw new Error(`Block or archive "${blockName}" not found.`);
+        }
+        const archivePath = join(archiveDir, resolved);
+        try {
+            await fsp.rm(archivePath, { recursive: true, force: true });
+            log.success(`"${resolved}" permanently deleted from archive.`);
+        }
+        catch (err) {
+            throw new Error(`Failed to delete: ${err.message}`);
+        }
+        return;
+    }
+    throw new Error(`Block "${blockName}" not found. Run \`mblk status\` to see available blocks.`);
+}
+export async function restoreCommand(archiveName) {
+    if (!(await isInitialized())) {
+        throw new Error(t.general.notInitialized);
+    }
+    const globalConfig = await loadGlobalConfig();
+    const blocksDir = resolveBlocksDir(globalConfig);
+    const archiveDir = join(blocksDir, '_archive');
+    // Resolve the archive — supports block name, full name, or prefix
+    const resolved = await resolveArchive(archiveDir, archiveName);
+    if (!resolved) {
+        throw new Error(`No archive found for "${archiveName}". Run \`mblk status\` to check archives.`);
+    }
+    const archivePath = join(archiveDir, resolved);
+    // Extract original block name (strip timestamp suffix)
+    const match = resolved.match(/^(.*?)_\d{4}-\d{2}-\d{2}T.*/);
+    const targetName = match ? match[1] : resolved;
+    const targetPath = join(blocksDir, targetName);
+    if (await pathExists(targetPath)) {
+        throw new Error(`Cannot restore: A block named "${targetName}" already exists. Delete or rename it first.`);
+    }
+    try {
+        await fsp.rename(archivePath, targetPath);
+        log.success(`Block "${targetName}" restored successfully.`);
+        log.dim(`  Start with: ${chalk.bold(`mblk start ${targetName}`)}`);
+    }
+    catch (err) {
+        throw new Error(`Failed to restore block: ${err.message}`);
+    }
+}
+//# sourceMappingURL=delete.js.map