@hasna/terminal 4.3.0 → 4.3.2

package/dist/mcp/tools/project.js

@@ -0,0 +1,251 @@
+// Project tools: boot, project_overview, run, install, status, help
+import { z } from "./helpers.js";
+import { estimateTokens } from "../../tokens.js";
+import { processOutput } from "../../output-processor.js";
+import { getOutputProvider } from "../../providers/index.js";
+import { getBootContext } from "../../session-boot.js";
+/** Detect project toolchain from filesystem */
+function detectToolchain(workDir) {
+    const { existsSync, readFileSync } = require("fs");
+    const { join } = require("path");
+    // JS/TS: bun > pnpm > yarn > npm
+    const hasBun = existsSync(join(workDir, "bun.lockb")) || existsSync(join(workDir, "bun.lock")) || (() => {
+        try {
+            return !!JSON.parse(readFileSync(join(workDir, "package.json"), "utf8")).engines?.bun;
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (hasBun)
+        return { runner: "bun", ecosystem: "js" };
+    if (existsSync(join(workDir, "pnpm-lock.yaml")))
+        return { runner: "pnpm", ecosystem: "js" };
+    if (existsSync(join(workDir, "yarn.lock")))
+        return { runner: "yarn", ecosystem: "js" };
+    if (existsSync(join(workDir, "deno.json")) || existsSync(join(workDir, "deno.jsonc")))
+        return { runner: "deno", ecosystem: "js" };
+    // Rust
+    if (existsSync(join(workDir, "Cargo.toml")))
+        return { runner: "cargo", ecosystem: "rust" };
+    // Go
+    if (existsSync(join(workDir, "go.mod")))
+        return { runner: "go", ecosystem: "go" };
+    // Python: poetry > pip
+    if (existsSync(join(workDir, "poetry.lock")))
+        return { runner: "poetry", ecosystem: "python" };
+    if (existsSync(join(workDir, "Pipfile")))
+        return { runner: "pipenv", ecosystem: "python" };
+    if (existsSync(join(workDir, "pyproject.toml")) || existsSync(join(workDir, "requirements.txt")))
+        return { runner: "pip", ecosystem: "python" };
+    // Ruby
+    if (existsSync(join(workDir, "Gemfile")))
+        return { runner: "bundle", ecosystem: "ruby" };
+    // PHP
+    if (existsSync(join(workDir, "composer.json")))
+        return { runner: "composer", ecosystem: "php" };
+    // Elixir
+    if (existsSync(join(workDir, "mix.exs")))
+        return { runner: "mix", ecosystem: "elixir" };
+    // .NET
+    if (existsSync(join(workDir, "*.csproj")) || existsSync(join(workDir, "*.fsproj")) || existsSync(join(workDir, "Directory.Build.props")))
+        return { runner: "dotnet", ecosystem: "dotnet" };
+    // Dart/Flutter
+    if (existsSync(join(workDir, "pubspec.yaml")))
+        return { runner: "dart", ecosystem: "dart" };
+    // Swift
+    if (existsSync(join(workDir, "Package.swift")))
+        return { runner: "swift", ecosystem: "swift" };
+    // Zig
+    if (existsSync(join(workDir, "build.zig")))
+        return { runner: "zig", ecosystem: "zig" };
+    // Make (generic)
+    if (existsSync(join(workDir, "Makefile")))
+        return { runner: "make", ecosystem: "make" };
+    // Fallback: npm if package.json exists
+    if (existsSync(join(workDir, "package.json")))
+        return { runner: "npm", ecosystem: "js" };
+    return { runner: "npm", ecosystem: "unknown" };
+}
+export function registerProjectTools(server, h) {
+    // ── boot ──────────────────────────────────────────────────────────────────
+    server.tool("boot", "Get everything an agent needs on session start in ONE call — git state, project info, source structure. Replaces: git status + git log + cat package.json + ls src/. Cached for the session.", async () => {
+        const ctx = await getBootContext(process.cwd());
+        return { content: [{ type: "text", text: JSON.stringify({
+                        ...ctx,
+                        hints: {
+                            cwd: process.cwd(),
+                            tip: "All terminal tools support relative paths. Use 'src/foo.ts' not the full absolute path. Use commit({message, push:true}) instead of raw git commands. Use run({task:'test'}) instead of bun/npm test. Use lookup({file, items}) instead of grep pipelines.",
+                        },
+                    }) }] };
+    });
+    // ── project_overview ──────────────────────────────────────────────────────
+    server.tool("project_overview", "Get project overview in one call — package.json info, source structure, config files. Replaces: cat package.json + ls src/ + cat tsconfig.json.", {
+        path: z.string().optional().describe("Project root (default: cwd)"),
+    }, async ({ path }) => {
+        const cwd = path ?? process.cwd();
+        const [pkgResult, srcResult, configResult] = await Promise.all([
+            h.exec("cat package.json 2>/dev/null", cwd),
+            h.exec("ls -1 src/ 2>/dev/null || ls -1 lib/ 2>/dev/null || ls -1 app/ 2>/dev/null", cwd),
+            h.exec("ls -1 *.json *.config.* .env* tsconfig* 2>/dev/null", cwd),
+        ]);
+        let pkg = null;
+        try {
+            pkg = JSON.parse(pkgResult.stdout);
+        }
+        catch { }
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        name: pkg?.name,
+                        version: pkg?.version,
+                        scripts: pkg?.scripts,
+                        dependencies: pkg?.dependencies ? Object.keys(pkg.dependencies) : [],
+                        devDependencies: pkg?.devDependencies ? Object.keys(pkg.devDependencies) : [],
+                        sourceFiles: srcResult.stdout.split("\n").filter(l => l.trim()),
+                        configFiles: configResult.stdout.split("\n").filter(l => l.trim()),
+                    }) }],
+        };
+    });
+    // ── run ───────────────────────────────────────────────────────────────────
+    server.tool("run", "Run a project task by intent — test, build, lint, dev, typecheck, format. Auto-detects toolchain (bun/npm/pnpm/yarn/cargo/go/make). Saves ~100 tokens vs raw commands.", {
+        task: z.string().describe("Task to run: test, build, lint, dev, start, typecheck, format, check — or any custom script name from package.json"),
+        args: z.string().optional().describe("Extra arguments (e.g., '--watch', 'src/foo.test.ts')"),
+        cwd: z.string().optional().describe("Working directory"),
+    }, async ({ task, args, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        const { runner, ecosystem } = detectToolchain(workDir);
+        const extra = args ? ` ${args}` : "";
+        // Map intent to command per ecosystem
+        const taskMap = {
+            rust: { test: "cargo test", build: "cargo build", lint: "cargo clippy", format: "cargo fmt", check: "cargo check" },
+            go: { test: "go test ./...", build: "go build ./...", lint: "golangci-lint run", format: "gofmt -w .", check: "go vet ./..." },
+            python: { test: "pytest", build: "python -m build", lint: "ruff check .", format: "ruff format .", check: "mypy .", typecheck: "mypy ." },
+            ruby: { test: "bundle exec rake test", build: "bundle exec rake build", lint: "bundle exec rubocop", format: "bundle exec rubocop -a" },
+            php: { test: "composer test", build: "composer build", lint: "composer lint", format: "composer format" },
+            elixir: { test: "mix test", build: "mix compile", lint: "mix credo", format: "mix format", check: "mix dialyzer" },
+            dotnet: { test: "dotnet test", build: "dotnet build", lint: "dotnet format --verify-no-changes", format: "dotnet format", check: "dotnet build --no-incremental" },
+            dart: { test: "dart test", build: "dart compile exe", lint: "dart analyze", format: "dart format ." },
+            swift: { test: "swift test", build: "swift build", lint: "swiftlint", format: "swiftformat ." },
+            zig: { test: "zig build test", build: "zig build" },
+            make: { test: "make test", build: "make build", lint: "make lint", format: "make format", check: "make check" },
+        };
+        let cmd;
+        if (ecosystem === "js") {
+            const prefix = runner === "yarn" ? "yarn" : `${runner} run`;
+            cmd = `${prefix} ${task}${extra}`;
+        }
+        else if (taskMap[ecosystem]?.[task]) {
+            cmd = `${taskMap[ecosystem][task]}${extra}`;
+        }
+        else {
+            cmd = `${runner} ${task}${extra}`;
+        }
+        const result = await h.exec(cmd, workDir, 120000);
+        const output = (result.stdout + result.stderr).trim();
+        const processed = await processOutput(cmd, output);
+        h.logCall("run", { command: `${task}${args ? ` ${args}` : ""}`, outputTokens: estimateTokens(output), tokensSaved: processed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode, aiProcessed: processed.aiProcessed });
+        return { content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode,
+                        task,
+                        runner,
+                        summary: processed.summary,
+                        tokensSaved: processed.tokensSaved,
+                    }) }] };
+    });
+    // ── install ───────────────────────────────────────────────────────────────
+    server.tool("install", "Install packages — auto-detects toolchain for any language. Agent says what to install, we figure out how.", {
+        packages: z.array(z.string()).describe("Package names to install"),
+        dev: z.boolean().optional().describe("Install as dev dependency (default: false)"),
+        cwd: z.string().optional().describe("Working directory"),
+    }, async ({ packages, dev, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        const { runner, ecosystem } = detectToolchain(workDir);
+        const pkgs = packages.join(" ");
+        const installMap = {
+            bun: { cmd: `bun add ${pkgs}`, devCmd: `bun add -D ${pkgs}` },
+            pnpm: { cmd: `pnpm add ${pkgs}`, devCmd: `pnpm add -D ${pkgs}` },
+            yarn: { cmd: `yarn add ${pkgs}`, devCmd: `yarn add --dev ${pkgs}` },
+            npm: { cmd: `npm install ${pkgs}`, devCmd: `npm install --save-dev ${pkgs}` },
+            deno: { cmd: `deno add ${pkgs}`, devCmd: `deno add --dev ${pkgs}` },
+            cargo: { cmd: `cargo add ${pkgs}`, devCmd: `cargo add --dev ${pkgs}` },
+            go: { cmd: `go get ${pkgs}`, devCmd: `go get ${pkgs}` },
+            pip: { cmd: `pip install ${pkgs}`, devCmd: `pip install ${pkgs}` },
+            poetry: { cmd: `poetry add ${pkgs}`, devCmd: `poetry add --group dev ${pkgs}` },
+            pipenv: { cmd: `pipenv install ${pkgs}`, devCmd: `pipenv install --dev ${pkgs}` },
+            bundle: { cmd: `bundle add ${pkgs}`, devCmd: `bundle add ${pkgs} --group development` },
+            composer: { cmd: `composer require ${pkgs}`, devCmd: `composer require --dev ${pkgs}` },
+            mix: { cmd: `mix deps.get`, devCmd: `mix deps.get` },
+            dotnet: { cmd: `dotnet add package ${pkgs}`, devCmd: `dotnet add package ${pkgs}` },
+            dart: { cmd: `dart pub add ${pkgs}`, devCmd: `dart pub add --dev ${pkgs}` },
+            swift: { cmd: `swift package add ${pkgs}`, devCmd: `swift package add ${pkgs}` },
+        };
+        const entry = installMap[runner] ?? installMap.npm;
+        const cmd = dev ? entry.devCmd : entry.cmd;
+        const result = await h.exec(cmd, workDir, 60000);
+        const output = (result.stdout + result.stderr).trim();
+        const processed = await processOutput(cmd, output);
+        h.logCall("install", { command: cmd, exitCode: result.exitCode, durationMs: Date.now() - start, aiProcessed: processed.aiProcessed });
+        return { content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode,
+                        command: cmd,
+                        summary: processed.summary,
+                    }) }] };
+    });
+    // ── status ────────────────────────────────────────────────────────────────
+    server.tool("status", "Get terminal server status, capabilities, and available parsers.", async () => {
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        name: "terminal", version: "3.3.0", cwd: process.cwd(),
+                        features: ["ai-output-processing", "token-compression", "noise-filtering", "diff-caching", "lazy-execution", "progressive-disclosure"],
+                    }) }],
+        };
+    });
+    // ── help ──────────────────────────────────────────────────────────────────
+    server.tool("help", "Get recommendations for which terminal tool to use. Describe what you want to do and get the best tool + usage example.", {
+        goal: z.string().optional().describe("What you're trying to do (e.g., 'run tests', 'find where login is defined', 'commit my changes')"),
+    }, async ({ goal }) => {
+        if (!goal) {
+            return { content: [{ type: "text", text: JSON.stringify({
+                            tools: {
+                                "execute / execute_smart": "Run any command. Smart = AI summary (80% fewer tokens)",
+                                "run({task})": "Run test/build/lint — auto-detects toolchain",
+                                "commit / bulk_commit / smart_commit": "Git commit — single, multi, or AI-grouped",
+                                "diff({ref})": "Show what changed with AI summary",
+                                "install({packages})": "Add packages — auto-detects bun/npm/pip/cargo",
+                                "search_content({pattern})": "Grep with structured results",
+                                "search_files({pattern})": "Find files by glob",
+                                "symbols({path})": "AI file outline — any language",
+                                "read_symbol({path, name})": "Read one function/class by name",
+                                "read_file({path, summarize})": "Read or AI-summarize a file",
+                                "read_files({files, summarize})": "Multi-file read in one call",
+                                "symbols_dir({path})": "Symbols for entire directory",
+                                "review({since})": "AI code review",
+                                "lookup({file, items})": "Find items in a file by name",
+                                "edit({file, find, replace})": "Find-replace in file",
+                                "repo_state": "Git branch + status + log in one call",
+                                "boot": "Full project context on session start",
+                                "watch({task})": "Run task on file change",
+                                "store_secret / list_secrets": "Secrets vault",
+                                "project_note({save/recall})": "Persistent project notes",
+                            },
+                            tips: [
+                                "Use relative paths — 'src/foo.ts' not '/Users/.../src/foo.ts'",
+                                "Use your native Read/Write/Edit for file operations when you don't need AI summary",
+                                "Use search_content for text patterns, symbols for code structure",
+                                "Use commit for single, bulk_commit for multiple, smart_commit for AI-grouped",
+                            ],
+                        }) }] };
+        }
+        // AI recommends the best tool for the goal
+        const provider = getOutputProvider();
+        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+        const recommendation = await provider.complete(`Agent wants to: ${goal}\n\nAvailable tools: execute, execute_smart, run, commit, bulk_commit, smart_commit, diff, install, search_content, search_files, symbols, read_symbol, read_file, read_files, symbols_dir, review, lookup, edit, repo_state, boot, watch, store_secret, list_secrets, project_note, help`, {
+            model: outputModel,
+            system: `Recommend the best terminal MCP tool for this goal. Return JSON: {"tool": "name", "example": {params}, "why": "one line"}. If multiple tools work, list top 2.`,
+            maxTokens: 200, temperature: 0,
+        });
+        return { content: [{ type: "text", text: recommendation }] };
+    });
+}

package/dist/mcp/tools/search.js

@@ -0,0 +1,86 @@
+// Search tools: search_content, search_files, search_semantic, lookup
+import { z } from "./helpers.js";
+import { searchFiles, searchContent, semanticSearch } from "../../search/index.js";
+export function registerSearchTools(server, h) {
+    // ── search_files ──────────────────────────────────────────────────────────
+    server.tool("search_files", "Search for files by name pattern. Auto-filters node_modules, .git, dist. Returns categorized results (source, config, other) with token savings.", {
+        pattern: z.string().describe("Glob pattern (e.g., '*hooks*', '*.test.ts')"),
+        path: z.string().optional().describe("Search root (default: cwd)"),
+        includeNodeModules: z.boolean().optional().describe("Include node_modules (default: false)"),
+        maxResults: z.number().optional().describe("Max results per category (default: 50)"),
+    }, async ({ pattern, path, includeNodeModules, maxResults }) => {
+        const start = Date.now();
+        const result = await searchFiles(pattern, path ?? process.cwd(), { includeNodeModules, maxResults });
+        h.logCall("search_files", { command: `search_files ${pattern}`, tokensSaved: result.tokensSaved ?? 0, durationMs: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ── search_content ────────────────────────────────────────────────────────
+    server.tool("search_content", "Search file contents by regex pattern. Groups matches by file, sorted by relevance. Use offset for pagination when results are truncated.", {
+        pattern: z.string().describe("Search pattern (regex)"),
+        path: z.string().optional().describe("Search root (default: cwd)"),
+        fileType: z.string().optional().describe("File type filter (e.g., 'ts', 'py')"),
+        maxResults: z.number().optional().describe("Max files to return (default: 30)"),
+        offset: z.number().optional().describe("Skip first N files (for pagination, default: 0)"),
+        contextLines: z.number().optional().describe("Context lines around matches (default: 0)"),
+    }, async ({ pattern, path, fileType, maxResults, offset, contextLines }) => {
+        const start = Date.now();
+        // Fetch more than needed to support offset
+        const fetchLimit = (maxResults ?? 30) + (offset ?? 0);
+        const result = await searchContent(pattern, path ?? process.cwd(), { fileType, maxResults: fetchLimit, contextLines });
+        // Apply offset
+        if (offset && offset > 0 && result.files) {
+            result.files = result.files.slice(offset);
+        }
+        h.logCall("search_content", { command: `grep ${pattern}`, tokensSaved: result.tokensSaved ?? 0, durationMs: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ── search_semantic ───────────────────────────────────────────────────────
+    server.tool("search_semantic", "Find functions, classes, components, hooks, types by NAME or SIGNATURE. Searches symbol declarations, NOT code behavior or content. Use search_content (grep) instead for pattern matching inside code (e.g., security audits, string searches, imports).", {
+        query: z.string().describe("Symbol name to search for (e.g., 'auth', 'login', 'UserService'). Matches function/class/type names, not code content."),
+        path: z.string().optional().describe("Search root (default: cwd)"),
+        kinds: z.array(z.enum(["function", "class", "interface", "type", "variable", "export", "import", "component", "hook"])).optional().describe("Filter by symbol kind"),
+        exportedOnly: z.boolean().optional().describe("Only show exported symbols (default: false)"),
+        maxResults: z.number().optional().describe("Max results (default: 30)"),
+    }, async ({ query, path, kinds, exportedOnly, maxResults }) => {
+        const result = await semanticSearch(query, path ?? process.cwd(), {
+            kinds: kinds,
+            exportedOnly,
+            maxResults,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ── lookup ────────────────────────────────────────────────────────────────
+    server.tool("lookup", "Search for specific items in a file by name or pattern. Agent says what to find, not how to grep. Saves ~300 tokens vs constructing grep pipelines.", {
+        file: z.string().describe("File path to search in"),
+        items: z.array(z.string()).describe("Names or patterns to look up"),
+        context: z.number().optional().describe("Lines of context around each match (default: 3)"),
+    }, async ({ file: rawFile, items, context }) => {
+        const start = Date.now();
+        const file = h.resolvePath(rawFile);
+        const { readFileSync } = await import("fs");
+        try {
+            const content = readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const ctx = context ?? 3;
+            const results = {};
+            for (const item of items) {
+                results[item] = [];
+                const pattern = new RegExp(item.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+                for (let i = 0; i < lines.length; i++) {
+                    if (pattern.test(lines[i])) {
+                        results[item].push({
+                            line: i + 1,
+                            text: lines[i].trim(),
+                            context: lines.slice(Math.max(0, i - ctx), i + ctx + 1).map(l => l.trimEnd()),
+                        });
+                    }
+                }
+            }
+            h.logCall("lookup", { command: `lookup ${file} [${items.join(",")}]`, durationMs: Date.now() - start });
+            return { content: [{ type: "text", text: JSON.stringify(results) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: e.message }) }] };
+        }
+    });
+}

package/dist/output-store.js

@@ -3,7 +3,8 @@
 import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
-const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
+import { getTerminalDir } from "./paths.js";
+const OUTPUTS_DIR = join(getTerminalDir(), "outputs");
 /** Ensure outputs directory exists */
 function ensureDir() {
     if (!existsSync(OUTPUTS_DIR))

package/dist/paths.js

@@ -0,0 +1,28 @@
+// Centralized path resolution for open-terminal global data directory.
+// Migrated from ~/.terminal/ to ~/.hasna/terminal/ with backward compat.
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Get the global terminal data directory.
+ * New default: ~/.hasna/terminal/
+ * Legacy fallback: ~/.terminal/ (if it exists and new dir doesn't)
+ * Env override: HASNA_TERMINAL_DIR or TERMINAL_DIR
+ */
+export function getTerminalDir() {
+    if (process.env.HASNA_TERMINAL_DIR)
+        return process.env.HASNA_TERMINAL_DIR;
+    if (process.env.TERMINAL_DIR)
+        return process.env.TERMINAL_DIR;
+    const home = homedir();
+    const newDir = join(home, ".hasna", "terminal");
+    const legacyDir = join(home, ".terminal");
+    // Use legacy dir if it exists and new one doesn't yet (backward compat)
+    if (!existsSync(newDir) && existsSync(legacyDir)) {
+        return legacyDir;
+    }
+    if (!existsSync(newDir)) {
+        mkdirSync(newDir, { recursive: true });
+    }
+    return newDir;
+}

package/dist/recipes/storage.js

@@ -1,9 +1,9 @@
-// Recipes storage — global (~/.terminal/recipes.json) + per-project (.terminal/recipes.json)
+// Recipes storage — global (~/.hasna/terminal/recipes.json) + per-project (.terminal/recipes.json)
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import { genId, extractVariables } from "./model.js";
-const GLOBAL_DIR = join(homedir(), ".terminal");
+import { getTerminalDir } from "../paths.js";
+const GLOBAL_DIR = getTerminalDir();
 const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
 function projectFile(projectPath) {
     return join(projectPath, ".terminal", "recipes.json");

package/dist/session-context.js

@@ -1,9 +1,9 @@
 // Session context — stores last N command+output pairs for follow-up queries
 // Enables: terminal "show auth code" → terminal "explain that function"
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
-const DIR = join(homedir(), ".terminal");
+import { getTerminalDir } from "./paths.js";
+const DIR = getTerminalDir();
 const CTX_FILE = join(DIR, "session-context.json");
 const MAX_ENTRIES = 5;
 function ensureDir() {

package/dist/sessions-db.js

@@ -1,19 +1,18 @@
 // SQLite session database — tracks every terminal interaction
-// @ts-ignore — bun:sqlite is a bun built-in
-import { Database } from "bun:sqlite";
+import { SqliteAdapter } from "@hasna/cloud";
 import { existsSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import { randomUUID } from "crypto";
-const DIR = join(homedir(), ".terminal");
-const DB_PATH = join(DIR, "sessions.db");
+import { getTerminalDir } from "./paths.js";
+const DIR = getTerminalDir();
+const DB_PATH = process.env.HASNA_TERMINAL_DB_PATH ?? process.env.TERMINAL_DB_PATH ?? join(DIR, "sessions.db");
 let db = null;
 function getDb() {
     if (db)
         return db;
     if (!existsSync(DIR))
         mkdirSync(DIR, { recursive: true });
-    db = new Database(DB_PATH);
+    db = new SqliteAdapter(DB_PATH);
     db.exec("PRAGMA journal_mode = WAL");
     db.exec(`
     CREATE TABLE IF NOT EXISTS sessions (
@@ -68,6 +67,16 @@ function getDb() {
     );
 
     CREATE INDEX IF NOT EXISTS idx_corrections_prompt ON corrections(prompt);
+
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
   `);
     return db;
 }

package/dist/snapshots.js

@@ -22,12 +22,12 @@ export function captureSnapshot() {
         port: p.port,
         uptime: Date.now() - p.startedAt,
     }));
-    // Recent commands (last 10, compressed)
+    // Recent commands (last 10)
     const history = loadHistory().slice(-10);
     const recentCommands = history.map(h => ({
         cmd: h.cmd,
         exitCode: h.error,
-        summary: h.nl !== h.cmd ? h.nl : undefined,
+        intent: h.nl !== h.cmd ? h.nl : undefined, // user's original NL intent, not AI-generated
     }));
     // Project recipes
     const recipes = listRecipes(process.cwd()).slice(0, 10).map(r => ({

package/dist/tool-profiles.js

@@ -1,9 +1,10 @@
 // Tool profiles — config-driven AI enhancement for specific command categories
-// Profiles are loaded from ~/.terminal/profiles/ (user-customizable)
+// Profiles are loaded from ~/.hasna/terminal/profiles/ (user-customizable)
 // Each profile tells the AI how to handle a specific tool's output
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
-const PROFILES_DIR = join(process.env.HOME ?? "~", ".terminal", "profiles");
+import { getTerminalDir } from "./paths.js";
+const PROFILES_DIR = join(getTerminalDir(), "profiles");
 /** Built-in profiles — sensible defaults, user can override */
 const BUILTIN_PROFILES = [
     {
@@ -68,7 +69,7 @@ const BUILTIN_PROFILES = [
         },
     },
 ];
-/** Load user profiles from ~/.terminal/profiles/ */
+/** Load user profiles from ~/.hasna/terminal/profiles/ */
 function loadUserProfiles() {
     if (!existsSync(PROFILES_DIR))
         return [];

package/dist/usage-cache.js

@@ -1,10 +1,10 @@
 // Usage learning cache — zero-cost repeated queries
 // After 3 identical prompt→command mappings, cache locally
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import { createHash } from "crypto";
-const DIR = join(homedir(), ".terminal");
+import { getTerminalDir } from "./paths.js";
+const DIR = getTerminalDir();
 const CACHE_FILE = join(DIR, "learned.json");
 function ensureDir() {
     if (!existsSync(DIR))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "files": [
@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@hasna/cloud": "^0.1.0",
     "@hasna/mementos": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@typescript/vfs": "^1.6.4",
@@ -29,9 +30,10 @@
     "react": "^18.2.0",
     "zod": "^4.3.6"
   },
+  "license": "Apache-2.0",
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
   },
   "repository": {
     "type": "git",

package/src/Onboarding.tsx

@@ -76,7 +76,7 @@ export default function Onboarding({ onDone }: Props) {
         })}
       </Box>
       <Box marginTop={1}><Text dimColor>space toggle  ·  enter confirm</Text></Box>
-      <Text dimColor>edit later: ~/.terminal/config.json</Text>
+      <Text dimColor>edit later: ~/.hasna/terminal/config.json</Text>
     </Box>
   );
 }

package/src/ai.ts

@@ -3,10 +3,11 @@ import { cacheGet, cacheSet } from "./cache.js";
 import { getProvider } from "./providers/index.js";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 import { discoverProjectHints, discoverSafetyHints, formatHints } from "./context-hints.js";
 
 // ── model routing ─────────────────────────────────────────────────────────────
-// Config-driven model selection. Defaults per provider, user can override in ~/.terminal/config.json
+// Config-driven model selection. Defaults per provider, user can override in ~/.hasna/terminal/config.json
 
 const COMPLEX_SIGNALS = [
   /\b(undo|revert|rollback|previous|last)\b/i,
@@ -18,7 +19,7 @@ const COMPLEX_SIGNALS = [
   /[|&;]{2}/,
 ];
 
-/** Default models per provider — user can override in ~/.terminal/config.json under "models" */
+/** Default models per provider — user can override in ~/.hasna/terminal/config.json under "models" */
 const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
   cerebras:  { fast: "qwen-3-235b-a22b-instruct-2507", smart: "qwen-3-235b-a22b-instruct-2507" },
   groq:      { fast: "openai/gpt-oss-120b",             smart: "moonshotai/kimi-k2-instruct" },
@@ -26,7 +27,7 @@ const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
   anthropic: { fast: "claude-haiku-4-5-20251001",       smart: "claude-sonnet-4-6" },
 };
 
-/** Load user model overrides from ~/.terminal/config.json (cached 30s) */
+/** Load user model overrides from ~/.hasna/terminal/config.json (cached 30s) */
 let _modelOverrides: Record<string, { fast?: string; smart?: string }> | null = null;
 let _modelOverridesAt = 0;
 
@@ -34,7 +35,7 @@ function loadModelOverrides(): Record<string, { fast?: string; smart?: string }>
   const now = Date.now();
   if (_modelOverrides && now - _modelOverridesAt < 30_000) return _modelOverrides;
   try {
-    const configPath = join(process.env.HOME ?? "~", ".terminal", "config.json");
+    const configPath = join(getTerminalDir(), "config.json");
     if (existsSync(configPath)) {
       const config = JSON.parse(readFileSync(configPath, "utf8"));
       _modelOverrides = config.models ?? {};
@@ -215,9 +216,9 @@ function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[], c
 list files in current directory → ls
 list all files including hidden → ls -a
 show open files → lsof
-create copy of a.txt as b.txt → cp a.txt b.txt
-create file test.txt → touch test.txt
-make directory testdir → mkdir testdir
+show file size → du -sh file
+show file type → file filename
+show file permissions → ls -la file
 display routing table → route
 show last logged in users → last
 show file stats → stat file
@@ -235,7 +236,7 @@ system utilization stats → vmstat
 DNS servers → cat /etc/resolv.conf | grep nameserver
 long integer size → getconf LONG_BIT
 base64 decode string → echo 'str' | base64 -d
-change owner to nobody → chown nobody file
+show file owner → ls -la file
 unique lines in file → uniq file
 max cpu time → ulimit -t
 memory info → lsmem

package/src/cache.ts

@@ -1,10 +1,10 @@
 // In-memory LRU cache + disk persistence for command translations
 
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const CACHE_FILE = join(homedir(), ".terminal", "cache.json");
+const CACHE_FILE = join(getTerminalDir(), "cache.json");
 const MAX_ENTRIES = 500;
 
 type CacheMap = Record<string, string>;

package/src/economy.ts

@@ -1,10 +1,10 @@
 // Token economy tracker — tracks token savings across all interactions
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const ECONOMY_FILE = join(DIR, "economy.json");
 
 export interface EconomyStats {
@@ -129,7 +129,7 @@ const PROVIDER_PRICING: Record<string, { input: number; output: number }> = {
   "anthropic-opus":   { input: 5.00, output: 25.00 },
 };
 
-/** Load configurable turns-before-compaction from ~/.terminal/config.json */
+/** Load configurable turns-before-compaction from ~/.hasna/terminal/config.json */
 function loadTurnsMultiplier(): number {
   try {
     const configPath = join(DIR, "config.json");