@adrive/cli 1.0.0 → 1.1.1

package/dist/lib/transcripts/util.js

@@ -0,0 +1,102 @@
+import { promises as fs } from 'node:fs';
+import { zstdDecompressSync } from 'node:zlib';
+const SUMMARY_CHARS = 160;
+const TITLE_CHARS = 120;
+// Only these input keys feed tool summaries, so file bodies (`content`,
+// `new_string`, ...) never reach a tool line.
+const SUMMARY_KEYS = ['command', 'cmd', 'file_path', 'filePath', 'notebook_path', 'path', 'pattern', 'query', 'url', 'description'];
+export function asObj(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+export function asStr(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+export async function readText(path) {
+    try {
+        const buf = await fs.readFile(path);
+        return (path.endsWith('.zst') ? zstdDecompressSync(buf) : buf).toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function jsonLines(raw) {
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = asObj(JSON.parse(line));
+            if (parsed)
+                out.push(parsed);
+        }
+        catch {
+            // Permissive: a torn last line or unknown record never fails a parse.
+        }
+    }
+    return out;
+}
+export function truncate(value, max) {
+    const flat = value.replace(/\s+/g, ' ').trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 3)}...`;
+}
+export function toolSummary(input) {
+    const obj = asObj(input);
+    if (!obj)
+        return typeof input === 'string' && input.trim() ? truncate(input.split('\n')[0], SUMMARY_CHARS) : undefined;
+    for (const key of SUMMARY_KEYS) {
+        const v = obj[key];
+        const s = Array.isArray(v) ? v.filter((x) => typeof x === 'string').join(' ') : asStr(v);
+        if (s && s.trim())
+            return truncate(s, SUMMARY_CHARS);
+    }
+    return undefined;
+}
+export function patchPaths(patch) {
+    const out = [];
+    for (const m of patch.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm))
+        out.push(m[1].trim());
+    return out;
+}
+export async function mtimeOf(path) {
+    try {
+        return (await fs.stat(path)).mtime;
+    }
+    catch {
+        return null;
+    }
+}
+export class DocBuilder {
+    turns = [];
+    files = new Set();
+    addTurn(role, text, ts, tools = []) {
+        const last = this.turns[this.turns.length - 1];
+        if (!text.trim()) {
+            if (tools.length === 0)
+                return;
+            // Harnesses log tool calls as separate records; fold them into the
+            // turn they belong to instead of emitting empty turns.
+            if (last && last.role === role) {
+                last.tools = [...(last.tools ?? []), ...tools];
+                return;
+            }
+        }
+        this.turns.push(tools.length > 0 ? { role, text, ts, tools } : { role, text, ts });
+    }
+    touch(path) {
+        if (path && path.trim())
+            this.files.add(path.trim());
+    }
+    build(entry, cwd, title) {
+        if (this.turns.length === 0)
+            return null;
+        const firstUser = this.turns.find((t) => t.role === 'user' && t.text.trim());
+        return {
+            entry,
+            turns: this.turns,
+            cwd: cwd ?? entry.cwd,
+            title: title?.trim() ? truncate(title, TITLE_CHARS) : firstUser ? truncate(firstUser.text, TITLE_CHARS) : undefined,
+            filesTouched: [...this.files],
+        };
+    }
+}

package/dist/lib/write-file.js

@@ -0,0 +1,55 @@
+import { constants, promises as fs } from 'node:fs';
+import { dirname } from 'node:path';
+export async function readTextIfExists(path) {
+    try {
+        return await fs.readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+// Throws on unparseable content so a merge never replaces a file it could not
+// read (JSONC with comments, a half-written file) with only our keys.
+export async function readJsonObject(path) {
+    const raw = await readTextIfExists(path);
+    if (raw === null)
+        return null;
+    if (!raw.trim())
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${path} is not plain JSON; left untouched`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${path} is not a JSON object; left untouched`);
+    }
+    return parsed;
+}
+export async function writeFileIfChanged(path, content, opts = {}) {
+    const current = await readTextIfExists(path);
+    if (current === content)
+        return 'unchanged';
+    await fs.mkdir(dirname(path), { recursive: true });
+    if (current !== null && opts.backup) {
+        // The first .bak is the user's pre-AgentDrive original; later runs must not overwrite it.
+        // 0600 because an original Codex config.toml can hold the API key init just removed.
+        try {
+            await fs.copyFile(path, `${path}.bak`, constants.COPYFILE_EXCL);
+            await fs.chmod(`${path}.bak`, 0o600);
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+    }
+    await fs.writeFile(path, content, 'utf8');
+    return current === null ? 'created' : 'updated';
+}
+export async function writeJsonIfChanged(path, value) {
+    return writeFileIfChanged(path, `${JSON.stringify(value, null, 2)}\n`, { backup: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adrive/cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "AgentDrive CLI — cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.",
   "license": "Apache-2.0",
   "type": "module",
@@ -37,18 +37,13 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc && node -e \"import('node:fs').then(fs => fs.chmodSync('dist/index.js', 0o755))\"",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
   "dependencies": {
     "chokidar": "^5.0.0",
     "commander": "^12.1.0",
     "kleur": "^4.1.5",
     "open": "^10.1.0",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "@adrive/mcp-server": "^1.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -57,6 +52,12 @@
     "vitest": "^2.1.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.15"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"import('node:fs').then(fs => fs.chmodSync('dist/index.js', 0o755))\"",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
-}
+}

package/dist/commands/transcripts.js

@@ -1,56 +0,0 @@
-import kleur from 'kleur';
-import { requireLogin } from '../lib/config.js';
-import { claudeSource } from '../lib/transcripts/claude.js';
-import { codexSource } from '../lib/transcripts/codex.js';
-import { cursorSource } from '../lib/transcripts/cursor.js';
-import { ingestSource } from '../lib/transcripts/ingest.js';
-const SOURCES = {
-    'claude-code': claudeSource,
-    codex: codexSource,
-    cursor: cursorSource,
-};
-function selectSources(platform) {
-    if (!platform || platform === 'all') {
-        // Cursor is intentionally excluded from --all until Phase 2.5 because its
-        // enumerate() throws. Users that want it must opt in explicitly with
-        // --platform cursor and get the "not yet" error.
-        return [claudeSource, codexSource];
-    }
-    const source = SOURCES[platform];
-    if (!source) {
-        throw new Error(`Unknown platform: ${platform}. Supported: claude-code, codex, cursor, all.`);
-    }
-    return [source];
-}
-export async function cmdTranscriptsIngest(opts = {}) {
-    const cfg = await requireLogin();
-    if (!cfg.preferences?.capture_transcripts && !opts.dryRun) {
-        process.stderr.write(`${kleur.yellow('[warn]')} Remember conversations is off in your preferences.\n` +
-            `       Enable with \`adrive privacy --capture-transcripts on\`,\n` +
-            `       or run a one-off dry-run with \`adrive transcripts ingest --dry-run\`.\n`);
-        process.exit(2);
-    }
-    const sources = selectSources(opts.platform);
-    let totalIngested = 0;
-    let totalSkipped = 0;
-    for (const source of sources) {
-        try {
-            const result = await ingestSource(source, cfg, {
-                workspace: opts.workspace,
-                since: opts.since,
-                dryRun: opts.dryRun,
-                limit: opts.limit,
-                reingest: opts.reingest,
-            });
-            totalIngested += result.ingested;
-            totalSkipped += result.skipped;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`${kleur.red('[err]')} ${source.platform}: ${msg}\n`);
-        }
-    }
-    if (sources.length > 1) {
-        process.stdout.write(`\n${kleur.bold('Total')}: ${totalIngested} ingested, ${totalSkipped} skipped.\n`);
-    }
-}

package/dist/lib/transcripts/ingest.js

@@ -1,115 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import kleur from 'kleur';
-import { CliApiClient } from '../api-client.js';
-import { configDir } from '../config.js';
-import { encryptContentAsync } from '../crypto.js';
-import { redact, summarizeHits } from '../redactor.js';
-function manifestPath() {
-    return join(configDir(), 'transcripts.manifest.json');
-}
-async function readManifest() {
-    try {
-        const raw = await fs.readFile(manifestPath(), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return { ingested: {} };
-    }
-}
-async function writeManifest(m) {
-    await fs.mkdir(configDir(), { recursive: true, mode: 0o700 });
-    await fs.writeFile(manifestPath(), JSON.stringify(m, null, 2), { encoding: 'utf8', mode: 0o600 });
-}
-function formatTranscript(turns) {
-    const lines = [];
-    for (const t of turns) {
-        lines.push(`## ${t.role}${t.ts ? `  _(${t.ts})_` : ''}`);
-        lines.push('');
-        lines.push(t.text);
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-function buildMarkdown(platform, doc) {
-    return (`# Transcript — ${platform} / ${doc.entry.sessionId}\n\n` +
-        `Project: ${doc.entry.label}\nLast modified: ${doc.entry.mtime.toISOString()}\n` +
-        `Turns: ${doc.turns.length}\n\n` +
-        formatTranscript(doc.turns));
-}
-export async function ingestSource(source, cfg, opts = {}) {
-    const home = opts.home ?? homedir();
-    const since = opts.since ? new Date(opts.since) : undefined;
-    if (since && Number.isNaN(since.getTime())) {
-        throw new Error('Invalid --since date.');
-    }
-    let entries = await source.enumerate({ home, since });
-    if (typeof opts.limit === 'number')
-        entries = entries.slice(0, opts.limit);
-    if (entries.length === 0) {
-        process.stdout.write(`No ${source.platform} transcripts found.\n`);
-        return { platform: source.platform, ingested: 0, skipped: 0 };
-    }
-    const manifest = await readManifest();
-    const client = new CliApiClient({
-        baseUrl: cfg.api_url,
-        apiKey: cfg.api_key,
-        agentPlatform: cfg.agent_platform ?? 'cli',
-        agentRole: cfg.agent_role,
-    });
-    let workspaceId = opts.workspace ?? cfg.default_workspace;
-    if (!workspaceId && !opts.dryRun) {
-        const list = await client.listWorkspaces();
-        if (list.length === 1)
-            workspaceId = list[0].id;
-        else if (list.length === 0)
-            throw new Error('No workspaces. Create one first.');
-        else
-            throw new Error('Multiple workspaces — specify --workspace <id>.');
-    }
-    const encrypt = !!cfg.preferences?.private_workspace;
-    process.stdout.write(`${kleur.bold(`Found ${entries.length} ${source.platform} transcripts.`)}\n`);
-    let ingested = 0;
-    let skipped = 0;
-    for (const entry of entries) {
-        if (!opts.reingest && manifest.ingested[entry.manifestKey]) {
-            skipped++;
-            continue;
-        }
-        const doc = await source.parseSession(entry);
-        if (!doc) {
-            skipped++;
-            continue;
-        }
-        const md = buildMarkdown(source.platform, doc);
-        const { redacted, hits } = redact(md);
-        const tag = summarizeHits(hits);
-        const remotePath = `transcripts/${source.platform}/${entry.sessionId}.md`;
-        if (opts.dryRun) {
-            process.stdout.write(`${kleur.dim('[dry]')} ${remotePath} ${kleur.dim(`(${doc.turns.length} turns, redactor: ${tag})`)}\n`);
-            ingested++;
-            continue;
-        }
-        try {
-            const body = encrypt ? await encryptContentAsync(cfg.api_key, redacted) : redacted;
-            await client.writeFile(workspaceId, remotePath, body, `transcript ingest (${tag})`);
-            manifest.ingested[entry.manifestKey] = new Date().toISOString();
-            ingested++;
-            process.stdout.write(`${kleur.green('[ok]')}  ${remotePath}` +
-                (encrypt ? kleur.cyan(' (encrypted)') : '') +
-                (hits.length ? kleur.yellow(` (redacted: ${tag})`) : '') +
-                '\n');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const base = entry.path.split('/').pop() ?? entry.path;
-            process.stderr.write(`${kleur.red('[err]')} ${base}: ${msg}\n`);
-        }
-    }
-    if (!opts.dryRun)
-        await writeManifest(manifest);
-    process.stdout.write(`\nIngested ${ingested}, skipped ${skipped}.\n`);
-    return { platform: source.platform, ingested, skipped };
-}
-export { buildMarkdown, formatTranscript };