@qvac/harness 0.0.0 → 0.1.1

package/dist-lib/lib/tools/exec/obsidian/output.js

@@ -0,0 +1,31 @@
+const TIMESTAMP_PREFIX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} /;
+const NOISE_RULES = [
+    { kind: 'startsWith', text: 'Loaded main app package ' },
+    { kind: 'startsWith', text: 'Loaded updated app package ' },
+    { kind: 'startsWith', text: 'Ignored: Error: Argument must be a file path' },
+    { kind: 'startsWith', text: 'Checking for update using Github' },
+    { kind: 'equals', text: 'Success.' },
+    { kind: 'startsWith', text: 'Latest version is ' },
+    { kind: 'equals', text: 'App is up to date.' },
+    { kind: 'includes', text: 'representedObject is not a WeakPtrToElectronMenuModelAsNSObject' },
+    { kind: 'startsWith', text: 'Received command line ' }
+];
+function isNoiseLine(line) {
+    for (const rule of NOISE_RULES) {
+        if (rule.kind === 'startsWith' && line.startsWith(rule.text))
+            return true;
+        if (rule.kind === 'equals' && line === rule.text)
+            return true;
+        if (rule.kind === 'includes' && line.includes(rule.text))
+            return true;
+    }
+    return false;
+}
+export function cleanObsidianOutput(raw) {
+    return raw
+        .split('\n')
+        .map((line) => line.replace(TIMESTAMP_PREFIX, ''))
+        .filter((line) => line.trim() !== '' && !isNoiseLine(line))
+        .join('\n')
+        .trim();
+}

package/dist-lib/lib/tools/exec/obsidian/route.d.ts

@@ -0,0 +1,19 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ToolExecuteContext } from '../../../capabilities/completion.ts';
+import { type CredentialStoreFn } from '../../skills/auth-resolver.ts';
+import { type ExecResult, type KillProcess, type SpawnFn } from '../runner.ts';
+export type ObsidianRouteOptions = {
+    readonly credentialStore?: CredentialStoreFn;
+    readonly spawn?: SpawnFn;
+    readonly killProcess?: KillProcess;
+    readonly loadRuntime?: () => Promise<{
+        spawn: SpawnFn;
+        killProcess?: KillProcess;
+    }>;
+    readonly platform?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly timeoutMs?: number;
+    readonly maxOutputChars?: number;
+    readonly signal?: BareAbortSignal;
+};
+export declare function routeObsidianCommand(command: string, ctx: ToolExecuteContext | undefined, options?: ObsidianRouteOptions): Promise<ExecResult | null>;

package/dist-lib/lib/tools/exec/obsidian/route.js

@@ -0,0 +1,85 @@
+import process from 'process';
+import { credentialRecord } from "../../skills/auth-resolver.js";
+import { isObsidianVaultPath, isSandboxedWorkbenchInstall, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY } from "../../skills/obsidian-readiness.js";
+import { capOutput, MAX_OUTPUT_CHARS } from "../runner.js";
+import { runObsidianCli } from "./cli.js";
+import { normalizeObsidianCommand, parseObsidianCommand } from "./command.js";
+import { OBSIDIAN_DESKTOP_AGENT_REQUIRED, OBSIDIAN_NO_SHELL_FALLBACK, OBSIDIAN_VAULT_SETUP_REQUIRED } from "./guidance.js";
+import { executeVaultFsAction } from "./vault-fs.js";
+const DESKTOP_PLATFORMS = new Set(['darwin', 'linux', 'win32']);
+function limitResult(result, maxOutputChars) {
+    return {
+        stdout: capOutput(result.stdout, maxOutputChars),
+        stderr: capOutput(result.stderr, maxOutputChars),
+        exitCode: result.exitCode
+    };
+}
+function vaultFsResult(stdout, exitCode) {
+    return exitCode === 0
+        ? { stdout, stderr: '', exitCode: 0 }
+        : { stdout: '', stderr: `${stdout}\n\n${OBSIDIAN_NO_SHELL_FALLBACK}`, exitCode };
+}
+function runVaultFs(vaultPath, action, args, maxOutputChars) {
+    try {
+        return limitResult(vaultFsResult(executeVaultFsAction(vaultPath, action, args), 0), maxOutputChars);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return limitResult(vaultFsResult(message, 1), maxOutputChars);
+    }
+}
+async function resolveVaultPath(credentialStore, ctx) {
+    if (!credentialStore)
+        return null;
+    const record = credentialRecord(await credentialStore(OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, ctx));
+    const token = record?.token?.trim();
+    if (!token || !isObsidianVaultPath(token))
+        return null;
+    return token;
+}
+export async function routeObsidianCommand(command, ctx, options = {}) {
+    const parsed = parseObsidianCommand(command);
+    if (!parsed)
+        return null;
+    const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
+    const signal = options.signal ?? ctx?.signal;
+    if (signal?.aborted) {
+        return { stdout: '', stderr: 'Obsidian command aborted.', exitCode: 1 };
+    }
+    const platform = options.platform ?? process.platform;
+    if (!DESKTOP_PLATFORMS.has(platform)) {
+        return {
+            stdout: '',
+            stderr: OBSIDIAN_DESKTOP_AGENT_REQUIRED,
+            exitCode: 1
+        };
+    }
+    const vaultPath = await resolveVaultPath(options.credentialStore, ctx);
+    if (vaultPath)
+        return runVaultFs(vaultPath, parsed.action, parsed.args, maxOutputChars);
+    if (isSandboxedWorkbenchInstall(options.env ?? process.env)) {
+        return {
+            stdout: '',
+            stderr: OBSIDIAN_VAULT_SETUP_REQUIRED,
+            exitCode: 1
+        };
+    }
+    const runtime = options.spawn
+        ? { spawn: options.spawn, killProcess: options.killProcess }
+        : options.loadRuntime
+            ? await options.loadRuntime()
+            : null;
+    if (!runtime) {
+        return {
+            stdout: '',
+            stderr: 'Obsidian CLI runtime unavailable. Ask the user to open Obsidian / register the CLI.\n\n' +
+                OBSIDIAN_NO_SHELL_FALLBACK,
+            exitCode: 1
+        };
+    }
+    return runObsidianCli(normalizeObsidianCommand(command), runtime, {
+        timeoutMs: options.timeoutMs,
+        maxOutputChars,
+        signal
+    });
+}

package/dist-lib/lib/tools/exec/obsidian/safe-path.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureWithinRoot(root: string, rel: string): string;
+export declare function isSymlink(p: string): boolean;
+export declare function writeNewFileText(filePath: string, content: string): void;

package/dist-lib/lib/tools/exec/obsidian/safe-path.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+function lstatOrNull(p) {
+    try {
+        return fs.lstatSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+function rejectSymlinkComponents(root, target) {
+    const segments = target.slice(root.length).split(path.sep).filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+        current = path.join(current, segment);
+        const stat = lstatOrNull(current);
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Path "${target}" crosses a symlink inside the vault.`);
+        }
+    }
+}
+export function ensureWithinRoot(root, rel) {
+    const resolvedRoot = path.resolve(root);
+    const target = path.resolve(resolvedRoot, rel);
+    if (target !== resolvedRoot && !target.startsWith(resolvedRoot + path.sep)) {
+        throw new Error(`Path "${rel}" escapes the vault root.`);
+    }
+    rejectSymlinkComponents(resolvedRoot, target);
+    return target;
+}
+export function isSymlink(p) {
+    return lstatOrNull(p)?.isSymbolicLink() === true;
+}
+export function writeNewFileText(filePath, content) {
+    if (fs.existsSync(filePath)) {
+        throw new Error(`Destination already exists: ${filePath}`);
+    }
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'wx');
+    }
+    catch (error) {
+        if (fs.existsSync(filePath)) {
+            throw new Error(`Destination already exists: ${filePath}`);
+        }
+        throw error;
+    }
+    try {
+        fs.writeSync(fd, content);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist-lib/lib/tools/exec/obsidian/vault-create.d.ts

@@ -0,0 +1 @@
+export declare function handleCreate(vaultPath: string, args: string[]): string;

package/dist-lib/lib/tools/exec/obsidian/vault-create.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import { markdownFileName } from "./note-name.js";
+import { ensureWithinRoot, getArg, getContentArg, writeNewFileText } from "./vault-paths.js";
+function markdownPath(vaultPath, target) {
+    const notePath = target.endsWith('.md') ? target : `${target}.md`;
+    return ensureWithinRoot(vaultPath, notePath);
+}
+function createAtPath(vaultPath, target, content) {
+    const filePath = markdownPath(vaultPath, target);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    writeNewFileText(filePath, content);
+    return `Created: ${path.relative(vaultPath, filePath)}`;
+}
+function createNamed(vaultPath, name, folder, content) {
+    const dir = folder ? ensureWithinRoot(vaultPath, folder) : path.resolve(vaultPath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const fileName = markdownFileName(name);
+    const filePath = ensureWithinRoot(vaultPath, path.join(folder, fileName));
+    if (fs.existsSync(filePath)) {
+        throw new Error(`Note "${name}" already exists at ${folder || '/'}`);
+    }
+    writeNewFileText(filePath, content);
+    return `Created: ${folder ? `${folder}/` : ''}${fileName}`;
+}
+export function handleCreate(vaultPath, args) {
+    const content = getContentArg(args);
+    const name = getArg(args, 'name');
+    if (name)
+        return createNamed(vaultPath, name, getArg(args, 'path') || '', content || '');
+    const filePath = getArg(args, 'path');
+    const file = getArg(args, 'file');
+    if (filePath && file)
+        return createNamed(vaultPath, file, filePath, content || '');
+    const target = filePath ?? file;
+    if (!target)
+        throw new Error('Missing required argument: name=, file=, or path=');
+    return createAtPath(vaultPath, target, content || '');
+}

package/dist-lib/lib/tools/exec/obsidian/vault-fs.d.ts

@@ -0,0 +1,3 @@
+export { parseObsidianCommand, normalizeObsidianCommand } from './command.ts';
+export { ensureWithinRoot } from './vault-paths.ts';
+export declare function executeVaultFsAction(vaultPath: string, action: string, args: string[]): string;

package/dist-lib/lib/tools/exec/obsidian/vault-fs.js

@@ -0,0 +1,57 @@
+import { handleCreate } from "./vault-create.js";
+import { todayStamp } from "./vault-paths.js";
+import { handleDailyRead, handleFiles, handleFolders, handleOutline, handleProperties, handleRead, handleSearch, handleTags, handleVault, handleVaults, handleWordcount } from "./vault-read.js";
+import { handleAppend, handleDailyAppend, handleDelete, handleMove, handlePrepend, handlePropertySet, handleRename } from "./vault-write.js";
+export { parseObsidianCommand, normalizeObsidianCommand } from "./command.js";
+export { ensureWithinRoot } from "./vault-paths.js";
+export function executeVaultFsAction(vaultPath, action, args) {
+    switch (action) {
+        case 'vault':
+            return handleVault(vaultPath);
+        case 'vaults':
+            return handleVaults(vaultPath);
+        case 'read':
+            return handleRead(vaultPath, args);
+        case 'create':
+            return handleCreate(vaultPath, args);
+        case 'append':
+            return handleAppend(vaultPath, args);
+        case 'prepend':
+            return handlePrepend(vaultPath, args);
+        case 'delete':
+            return handleDelete(vaultPath, args);
+        case 'move':
+            return handleMove(vaultPath, args);
+        case 'rename':
+            return handleRename(vaultPath, args);
+        case 'files':
+        case 'file':
+            return handleFiles(vaultPath, args);
+        case 'folders':
+        case 'folder':
+            return handleFolders(vaultPath);
+        case 'search':
+        case 'search:context':
+            return handleSearch(vaultPath, args);
+        case 'properties':
+        case 'property:read':
+            return handleProperties(vaultPath, args);
+        case 'property:set':
+            return handlePropertySet(vaultPath, args);
+        case 'tags':
+            return handleTags(vaultPath);
+        case 'wordcount':
+            return handleWordcount(vaultPath, args);
+        case 'outline':
+            return handleOutline(vaultPath, args);
+        case 'daily:read':
+            return handleDailyRead(vaultPath);
+        case 'daily:append':
+            return handleDailyAppend(vaultPath, args);
+        case 'daily:path':
+            return `Daily Notes/${todayStamp()}.md`;
+        default:
+            throw new Error(`Action "${action}" is not supported in vault file mode. ` +
+                `This action requires the Obsidian CLI connected to the running app.`);
+    }
+}

package/dist-lib/lib/tools/exec/obsidian/vault-paths.d.ts

@@ -0,0 +1,20 @@
+export { ensureWithinRoot, writeNewFileText } from './safe-path.ts';
+export declare const FRONTMATTER_RE: RegExp;
+export declare function resolveNotePath(vaultPath: string, args: string[]): string | null;
+export declare function readFileText(filePath: string): string;
+export type FileSnapshot = {
+    readonly text: string;
+    readonly mtimeMs: number;
+};
+export declare function readFileSnapshot(filePath: string): FileSnapshot | null;
+export declare function writeIfUnchanged(filePath: string, content: string, expectedMtimeMs: number | null): void;
+export declare function updateFileText(filePath: string, transform: (existing: string) => string): void;
+export declare function appendToFile(filePath: string, content: string): void;
+export declare function moveFile(src: string, dest: string): void;
+export declare function listMarkdownFiles(dir: string, prefix?: string): string[];
+export declare function listFolders(dir: string, prefix?: string): string[];
+export declare function parseFrontmatter(content: string): Record<string, string>;
+export declare function getContentArg(args: string[]): string;
+export declare function getArg(args: string[], key: string): string | undefined;
+export declare function todayStamp(): string;
+export declare function dailyCandidates(vaultPath: string, dateStr: string): Iterable<string>;

package/dist-lib/lib/tools/exec/obsidian/vault-paths.js

@@ -0,0 +1,171 @@
+import fs from 'fs';
+import path from 'path';
+import { ensureWithinRoot, isSymlink, writeNewFileText } from "./safe-path.js";
+export { ensureWithinRoot, writeNewFileText } from "./safe-path.js";
+export const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+export function resolveNotePath(vaultPath, args) {
+    const fileArg = args.find((a) => a.startsWith('file='));
+    const pathArg = args.find((a) => a.startsWith('path='));
+    if (pathArg) {
+        return ensureWithinRoot(vaultPath, pathArg.slice('path='.length));
+    }
+    if (fileArg) {
+        const name = fileArg.slice('file='.length);
+        const withExt = name.endsWith('.md') ? name : `${name}.md`;
+        const direct = ensureWithinRoot(vaultPath, withExt);
+        if (fs.existsSync(direct))
+            return direct;
+        return findFileRecursive(vaultPath, withExt);
+    }
+    return null;
+}
+function readDirEntries(dir) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (name.startsWith('.'))
+            continue;
+        const full = path.join(dir, name);
+        if (isSymlink(full))
+            continue;
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        out.push({ name, full, isDir: stat.isDirectory() });
+    }
+    return out;
+}
+function namesMatch(a, b) {
+    return a === b || a.toLowerCase() === b.toLowerCase();
+}
+function findFileRecursive(dir, target) {
+    for (const entry of readDirEntries(dir)) {
+        if (entry.isDir) {
+            const found = findFileRecursive(entry.full, target);
+            if (found)
+                return found;
+        }
+        else if (namesMatch(entry.name, target)) {
+            return entry.full;
+        }
+    }
+    return null;
+}
+export function readFileText(filePath) {
+    return fs.readFileSync(filePath, 'utf8');
+}
+export function readFileSnapshot(filePath) {
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+    if (!stat.isFile())
+        return null;
+    return { text: fs.readFileSync(filePath, 'utf8'), mtimeMs: stat.mtimeMs };
+}
+export function writeIfUnchanged(filePath, content, expectedMtimeMs) {
+    let current = null;
+    try {
+        current = fs.statSync(filePath);
+    }
+    catch {
+        current = null;
+    }
+    if (expectedMtimeMs === null) {
+        if (current) {
+            throw new Error(`Note changed on disk during update (file appeared): ${path.basename(filePath)}`);
+        }
+        fs.writeFileSync(filePath, content);
+        return;
+    }
+    if (!current || current.mtimeMs !== expectedMtimeMs) {
+        throw new Error(`Note changed on disk during update (re-read and retry): ${path.basename(filePath)}`);
+    }
+    fs.writeFileSync(filePath, content);
+}
+export function updateFileText(filePath, transform) {
+    const snap = readFileSnapshot(filePath);
+    if (!snap) {
+        writeIfUnchanged(filePath, transform(''), null);
+        return;
+    }
+    writeIfUnchanged(filePath, transform(snap.text), snap.mtimeMs);
+}
+export function appendToFile(filePath, content) {
+    updateFileText(filePath, (existing) => existing + content);
+}
+export function moveFile(src, dest) {
+    const content = readFileText(src);
+    writeNewFileText(dest, content);
+    fs.rmSync(src);
+}
+export function listMarkdownFiles(dir, prefix = '') {
+    const results = [];
+    for (const entry of readDirEntries(dir)) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDir)
+            results.push(...listMarkdownFiles(entry.full, rel));
+        else if (entry.name.endsWith('.md'))
+            results.push(rel);
+    }
+    return results;
+}
+export function listFolders(dir, prefix = '') {
+    const results = [];
+    for (const entry of readDirEntries(dir)) {
+        if (entry.isDir) {
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            results.push(rel);
+            results.push(...listFolders(entry.full, rel));
+        }
+    }
+    return results;
+}
+export function parseFrontmatter(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match?.[1])
+        return {};
+    const props = {};
+    for (const line of match[1].split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        if (key)
+            props[key] = value;
+    }
+    return props;
+}
+export function getContentArg(args) {
+    const arg = args.find((a) => a.startsWith('content='));
+    if (!arg)
+        return '';
+    return arg.slice('content='.length).replace(/\\n/g, '\n');
+}
+export function getArg(args, key) {
+    const arg = args.find((a) => a.startsWith(`${key}=`));
+    return arg ? arg.slice(key.length + 1) : undefined;
+}
+export function todayStamp() {
+    const today = new Date();
+    return `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
+}
+export function* dailyCandidates(vaultPath, dateStr) {
+    yield ensureWithinRoot(vaultPath, `${dateStr}.md`);
+    yield ensureWithinRoot(vaultPath, path.join('Daily Notes', `${dateStr}.md`));
+    yield ensureWithinRoot(vaultPath, path.join('daily', `${dateStr}.md`));
+}

package/dist-lib/lib/tools/exec/obsidian/vault-read.d.ts

@@ -0,0 +1,11 @@
+export declare function handleVault(vaultPath: string): string;
+export declare function handleVaults(vaultPath: string): string;
+export declare function handleRead(vaultPath: string, args: string[]): string;
+export declare function handleFiles(vaultPath: string, args: string[]): string;
+export declare function handleFolders(vaultPath: string): string;
+export declare function handleSearch(vaultPath: string, args: string[]): string;
+export declare function handleProperties(vaultPath: string, args: string[]): string;
+export declare function handleTags(vaultPath: string): string;
+export declare function handleWordcount(vaultPath: string, args: string[]): string;
+export declare function handleOutline(vaultPath: string, args: string[]): string;
+export declare function handleDailyRead(vaultPath: string): string;

package/dist-lib/lib/tools/exec/obsidian/vault-read.js

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import { dailyCandidates, ensureWithinRoot, FRONTMATTER_RE, getArg, listFolders, listMarkdownFiles, parseFrontmatter, readFileText, resolveNotePath, todayStamp } from "./vault-paths.js";
+export function handleVault(vaultPath) {
+    return JSON.stringify({ name: path.basename(vaultPath), path: vaultPath });
+}
+export function handleVaults(vaultPath) {
+    return JSON.stringify([
+        {
+            name: path.basename(vaultPath),
+            path: vaultPath,
+            source: 'configured_vault_path',
+            note: 'Vault file mode can access the configured vault folder only.'
+        }
+    ], null, 2);
+}
+export function handleRead(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    return readFileText(notePath);
+}
+export function handleFiles(vaultPath, args) {
+    const folder = getArg(args, 'folder');
+    const dir = folder ? ensureWithinRoot(vaultPath, folder) : path.resolve(vaultPath);
+    const files = listMarkdownFiles(dir, folder ?? '');
+    return files.join('\n') || '(empty)';
+}
+export function handleFolders(vaultPath) {
+    return listFolders(path.resolve(vaultPath)).join('\n') || '(empty)';
+}
+const SEARCH_LIMIT_DEFAULT = 50;
+const SEARCH_LIMIT_MAX = 200;
+function parseLimit(args) {
+    const raw = getArg(args, 'limit');
+    const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    if (!Number.isFinite(n) || n <= 0)
+        return SEARCH_LIMIT_DEFAULT;
+    return Math.min(n, SEARCH_LIMIT_MAX);
+}
+export function handleSearch(vaultPath, args) {
+    const query = getArg(args, 'query');
+    if (!query)
+        throw new Error('Missing required argument: query=');
+    const limit = parseLimit(args);
+    const lowerQuery = query.toLowerCase();
+    const files = listMarkdownFiles(path.resolve(vaultPath));
+    const matches = [];
+    for (const relPath of files) {
+        if (matches.length >= limit)
+            break;
+        const fullPath = path.join(path.resolve(vaultPath), relPath);
+        try {
+            if (readFileText(fullPath).toLowerCase().includes(lowerQuery))
+                matches.push(relPath);
+        }
+        catch {
+        }
+    }
+    if (matches.length === 0)
+        return `No results for "${query}"`;
+    const truncated = matches.length >= limit ? `\n(showing first ${limit}; narrow query for more)` : '';
+    return matches.join('\n') + truncated;
+}
+export function handleProperties(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    return JSON.stringify(parseFrontmatter(readFileText(notePath)), null, 2);
+}
+export function handleTags(vaultPath) {
+    const files = listMarkdownFiles(path.resolve(vaultPath));
+    const tagCounts = new Map();
+    const tagRe = /#([a-zA-Z0-9_/-]+)/g;
+    for (const relPath of files) {
+        try {
+            const content = readFileText(path.join(path.resolve(vaultPath), relPath));
+            for (const match of content.matchAll(tagRe)) {
+                const tag = match[1];
+                if (tag === undefined)
+                    continue;
+                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+            }
+        }
+        catch {
+        }
+    }
+    const sorted = Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]);
+    return sorted.map(([tag, count]) => `#${tag} (${count})`).join('\n') || '(no tags)';
+}
+export function handleWordcount(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const body = readFileText(notePath).replace(FRONTMATTER_RE, '').trim();
+    const words = body.split(/\s+/).filter(Boolean).length;
+    return `${words} words`;
+}
+export function handleOutline(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const headings = readFileText(notePath)
+        .split('\n')
+        .filter((line) => /^#{1,6}\s/.test(line));
+    return headings.join('\n') || '(no headings)';
+}
+export function handleDailyRead(vaultPath) {
+    const dateStr = todayStamp();
+    for (const p of dailyCandidates(vaultPath, dateStr)) {
+        if (fs.existsSync(p))
+            return readFileText(p);
+    }
+    return `No daily note found for ${dateStr}`;
+}

package/dist-lib/lib/tools/exec/obsidian/vault-write.d.ts

@@ -0,0 +1,7 @@
+export declare function handleAppend(vaultPath: string, args: string[]): string;
+export declare function handlePrepend(vaultPath: string, args: string[]): string;
+export declare function handleDelete(vaultPath: string, args: string[]): string;
+export declare function handleMove(vaultPath: string, args: string[]): string;
+export declare function handleRename(vaultPath: string, args: string[]): string;
+export declare function handlePropertySet(vaultPath: string, args: string[]): string;
+export declare function handleDailyAppend(vaultPath: string, args: string[]): string;