@hanhnd/agent-kit 1.0.31 → 1.0.33

package/dist/cli/commands/cli-digest-pending.test.js

@@ -0,0 +1,111 @@
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, describe, test } from 'node:test';
+import { createTempDirTracker } from '../../utils/temp-dir.test.js';
+import { runMemoryCli } from './memory.js';
+import { writeConversationDigestSettings } from '../../services/digest/files.js';
+import { DigestModelId } from '../../services/digest/types.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+function writeInitState(workspace) {
+    writeConversationDigestSettings(workspace, {
+        enabled: true,
+        initialized: true,
+        modelId: DigestModelId.DEFAULT,
+        initializedAt: new Date().toISOString(),
+    });
+}
+async function captureStdout(fn) {
+    const stdoutChunks = [];
+    const origWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (chunk) => {
+        stdoutChunks.push(String(chunk));
+        return true;
+    };
+    try {
+        const code = await fn();
+        return { code, output: stdoutChunks.join('') };
+    }
+    finally {
+        process.stdout.write = origWrite;
+    }
+}
+async function withWorkspace(workspace, fn) {
+    const previous = process.env.WORKSPACE_DIR;
+    process.env.WORKSPACE_DIR = workspace;
+    try {
+        return await fn();
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.WORKSPACE_DIR;
+        }
+        else {
+            process.env.WORKSPACE_DIR = previous;
+        }
+    }
+}
+describe('cmdDigestPending CLI', () => {
+    test('digest-pending returns 0 and emits one JSON line matching DigestPendingResult', async () => {
+        const workspace = tempDirs.makeTempDir('cli-pending-c23-');
+        const { code, output } = await withWorkspace(workspace, () => captureStdout(() => runMemoryCli(['digest-pending'], {
+            ...process.env,
+            WORKSPACE_DIR: workspace,
+        })));
+        assert.equal(code, 0);
+        const parsed = JSON.parse(output.trim());
+        assert.ok('ok' in parsed, 'result must have ok field');
+        assert.ok('action' in parsed, 'result must have action field');
+    });
+    test('--background returns launcher JSON without waiting for worker when no pending', async () => {
+        const workspace = tempDirs.makeTempDir('cli-pending-bg-');
+        writeInitState(workspace);
+        const { code, output } = await withWorkspace(workspace, () => captureStdout(() => runMemoryCli(['digest-pending', '--background'], {
+            ...process.env,
+            WORKSPACE_DIR: workspace,
+        })));
+        assert.equal(code, 0);
+        const parsed = JSON.parse(output.trim());
+        assert.equal(parsed.mode, 'background-launcher');
+        assert.equal(parsed.spawned, false);
+        assert.equal(parsed.status.state, 'no-pending');
+    });
+    test('--background worker flag returns final worker status JSON', async () => {
+        const workspace = tempDirs.makeTempDir('cli-pending-worker-');
+        writeInitState(workspace);
+        const { code, output } = await withWorkspace(workspace, () => captureStdout(() => runMemoryCli(['digest-pending', '--background', '--__agent-kit-digest-worker'], {
+            ...process.env,
+            WORKSPACE_DIR: workspace,
+        })));
+        assert.equal(code, 0);
+        const parsed = JSON.parse(output.trim());
+        assert.equal(parsed.state, 'no-pending');
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.status.json')), true);
+    });
+    test('--background emits failed launcher JSON quickly when spawn preflight cannot find entrypoint', async () => {
+        const workspace = tempDirs.makeTempDir('cli-pending-bg-fast-');
+        writeInitState(workspace);
+        const rawDir = path.join(workspace, '.agent-kit', 'wiki', 'raw');
+        fs.mkdirSync(rawDir, { recursive: true });
+        fs.writeFileSync(path.join(rawDir, 'conv_2026-01-01T00-00-00-001Z.md'), '**User:** hello\n', 'utf8');
+        const previousArgv = process.argv[1];
+        process.argv[1] = '';
+        try {
+            const { code, output } = await withWorkspace(workspace, () => captureStdout(() => runMemoryCli(['digest-pending', '--background'], {
+                ...process.env,
+                WORKSPACE_DIR: workspace,
+            })));
+            assert.equal(code, 0);
+            const parsed = JSON.parse(output.trim());
+            assert.equal(parsed.mode, 'background-launcher');
+            assert.equal(parsed.spawned, false);
+            assert.equal(parsed.status.state, 'failed');
+        }
+        finally {
+            process.argv[1] = previousArgv;
+        }
+    });
+});

package/dist/cli/commands/cli-memory.test.js

@@ -0,0 +1,34 @@
+import * as assert from 'node:assert/strict';
+import { afterEach, describe, test } from 'node:test';
+import { createTempDirTracker } from '../../utils/temp-dir.test.js';
+import { runMemoryCli } from './memory.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+describe('memory CLI', () => {
+    test('digest-pending returns 0 when settings are missing', async () => {
+        const workspace = tempDirs.makeTempDir('digest-pending-');
+        const previous = process.env.WORKSPACE_DIR;
+        process.env.WORKSPACE_DIR = workspace;
+        try {
+            const code = await runMemoryCli(['digest-pending'], {
+                ...process.env,
+                WORKSPACE_DIR: workspace,
+            });
+            assert.equal(code, 0);
+        }
+        finally {
+            if (previous === undefined) {
+                delete process.env.WORKSPACE_DIR;
+            }
+            else {
+                process.env.WORKSPACE_DIR = previous;
+            }
+        }
+    });
+    test('unknown command returns 1', async () => {
+        const code = await runMemoryCli(['unknown'], process.env);
+        assert.equal(code, 1);
+    });
+});

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

@@ -0,0 +1 @@
+export declare function runMemoryCli(args: string[], _env: NodeJS.ProcessEnv): Promise<number>;

package/dist/cli/commands/memory.js

@@ -0,0 +1,90 @@
+import { initializeConversationDigestModel, digestConversationFile, digestPendingConversations, } from '../../services/digest/processor.js';
+import { launchDigestPendingWorker, runDigestPendingWorker } from '../../services/digest/background.js';
+import { isDigestWorkerInvocation, runDigestFileInWorker } from '../../services/digest/worker.js';
+import { DEFAULT_DIGEST_MAX_INPUT_CHARS, DEFAULT_DIGEST_MODEL_ID, DEFAULT_DIGEST_TIMEOUT_MS, DIGEST_WORKER_FLAG, DIGEST_WORKER_RESULT_PREFIX, } from '../../services/digest/constants.js';
+import { loadProjectSettings, resolveConversationDigestConfig } from '../../core/config/index.js';
+import { parseArgs, stringFlag, numberFlag } from '../utils/args.js';
+import { getWorkspaceRoot } from '../../utils/utils.js';
+function writeDigestFileResult(result, workerMode) {
+    if (workerMode) {
+        process.stdout.write(DIGEST_WORKER_RESULT_PREFIX + JSON.stringify(result) + '\n');
+        return;
+    }
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
+async function cmdDigestInit(args) {
+    const parsed = parseArgs(args);
+    const modelId = stringFlag(parsed.flags, 'model') ?? DEFAULT_DIGEST_MODEL_ID;
+    const result = await initializeConversationDigestModel({
+        workspaceRoot: getWorkspaceRoot(),
+        modelId,
+        allowDownload: true,
+    });
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    return result.initialized ? 0 : 1;
+}
+async function cmdDigestFile(args) {
+    const workerMode = isDigestWorkerInvocation(args);
+    const workerResult = runDigestFileInWorker(args);
+    if (workerResult !== undefined)
+        return workerResult;
+    const parsed = parseArgs(args);
+    const workspaceRoot = getWorkspaceRoot();
+    const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+    const modelId = stringFlag(parsed.flags, 'model') ?? digestConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID;
+    const inputPath = stringFlag(parsed.flags, 'input');
+    if (!inputPath) {
+        process.stderr.write('Usage: cli memory digest-file --input <path> --model <id>\n');
+        return 1;
+    }
+    const result = await digestConversationFile({
+        workspaceRoot,
+        inputPath,
+        modelId,
+        outDir: stringFlag(parsed.flags, 'out'),
+        maxInputChars: numberFlag(parsed.flags, 'max-input-chars', DEFAULT_DIGEST_MAX_INPUT_CHARS),
+        timeoutMs: numberFlag(parsed.flags, 'timeout-ms', DEFAULT_DIGEST_TIMEOUT_MS),
+    });
+    writeDigestFileResult(result, workerMode);
+    return 0;
+}
+async function cmdDigestPending(args) {
+    const parsed = parseArgs(args);
+    const workspaceRoot = getWorkspaceRoot();
+    const isBackground = parsed.flags.get('background') === true;
+    if (isBackground && parsed.flags.get(DIGEST_WORKER_FLAG) === true) {
+        const result = await runDigestPendingWorker({ workspaceRoot });
+        process.stdout.write(JSON.stringify(result) + '\n');
+        return 0;
+    }
+    if (isBackground) {
+        const result = launchDigestPendingWorker({
+            workspaceRoot,
+            args,
+            entrypoint: process.argv[1],
+        });
+        process.stdout.write(JSON.stringify(result) + '\n');
+        return 0;
+    }
+    const result = await digestPendingConversations({ workspaceRoot });
+    process.stdout.write(JSON.stringify(result) + '\n');
+    return 0;
+}
+export async function runMemoryCli(args, _env) {
+    const [command, ...rest] = args;
+    try {
+        if (command === 'digest-file')
+            return await cmdDigestFile(rest);
+        if (command === 'digest-init')
+            return await cmdDigestInit(rest);
+        if (command === 'digest-pending')
+            return await cmdDigestPending(rest);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write('[agent-kit] memory ' + (command ?? '') + ' failed: ' + message + '\n');
+        return 1;
+    }
+    process.stderr.write('Usage: cli memory <digest-file|digest-init|digest-pending>\n');
+    return 1;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function runAgentKitCli(argv: string[], env: NodeJS.ProcessEnv): Promise<number>;

package/dist/cli/index.js

@@ -0,0 +1,9 @@
+import { runMemoryCli } from './commands/memory.js';
+export async function runAgentKitCli(argv, env) {
+    const [command, ...rest] = argv;
+    if (command === 'memory') {
+        return runMemoryCli(rest, env);
+    }
+    process.stderr.write('Usage: cli memory <digest-file|digest-init|digest-pending>\n');
+    return 1;
+}

package/dist/cli/utils/args.d.ts

@@ -0,0 +1,8 @@
+interface ParsedArgs {
+    flags: Map<string, string | boolean>;
+    positionals: string[];
+}
+export declare function parseArgs(args: string[]): ParsedArgs;
+export declare function stringFlag(flags: Map<string, string | boolean>, key: string): string | undefined;
+export declare function numberFlag(flags: Map<string, string | boolean>, key: string, defaultValue: number | string): number;
+export {};

package/dist/cli/utils/args.js

@@ -0,0 +1,31 @@
+export function parseArgs(args) {
+    const flags = new Map();
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = args[index + 1];
+        if (!next || next.startsWith('--')) {
+            flags.set(key, true);
+            continue;
+        }
+        flags.set(key, next);
+        index += 1;
+    }
+    return { flags, positionals };
+}
+export function stringFlag(flags, key) {
+    const value = flags.get(key);
+    return typeof value === 'string' ? value : undefined;
+}
+export function numberFlag(flags, key, defaultValue) {
+    const value = Number(stringFlag(flags, key) ?? defaultValue);
+    if (!Number.isFinite(value)) {
+        throw new Error(`--${key} must be a finite number`);
+    }
+    return value;
+}