cli-jaw 2.0.1 → 2.0.2

package/public/manager/src/settings/pages/components/heartbeat-helpers.ts

@@ -55,31 +55,31 @@ function safeJob(raw: unknown, index: number): HbJob | null {
     if (!raw || typeof raw !== 'object') return null;
     const r = raw as Record<string, unknown>;
     const id =
-        typeof r.id === 'string' && r.id.trim()
-            ? r.id.trim()
+        typeof r['id'] === 'string' && r['id'].trim()
+            ? r['id'].trim()
             : `hb_unknown_${index}`;
-    const name = typeof r.name === 'string' ? r.name : '';
-    const enabled = r.enabled !== false;
-    const prompt = typeof r.prompt === 'string' ? r.prompt : '';
-    const sched = r.schedule;
+    const name = typeof r['name'] === 'string' ? r['name'] : '';
+    const enabled = r['enabled'] !== false;
+    const prompt = typeof r['prompt'] === 'string' ? r['prompt'] : '';
+    const sched = r['schedule'];
     let schedule: HbSchedule;
     if (sched && typeof sched === 'object') {
         const s = sched as Record<string, unknown>;
-        if (s.kind === 'cron' && typeof s.cron === 'string') {
+        if (s['kind'] === 'cron' && typeof s['cron'] === 'string') {
             schedule = {
                 kind: 'cron',
-                cron: s.cron,
-                ...(typeof s.timeZone === 'string' && s.timeZone
-                    ? { timeZone: s.timeZone }
+                cron: s['cron'],
+                ...(typeof s['timeZone'] === 'string' && s['timeZone']
+                    ? { timeZone: s['timeZone'] }
                     : {}),
             };
         } else {
-            const minutes = typeof s.minutes === 'number' ? s.minutes : 30;
+            const minutes = typeof s['minutes'] === 'number' ? s['minutes'] : 30;
             schedule = {
                 kind: 'every',
                 minutes,
-                ...(typeof s.timeZone === 'string' && s.timeZone
-                    ? { timeZone: s.timeZone }
+                ...(typeof s['timeZone'] === 'string' && s['timeZone']
+                    ? { timeZone: s['timeZone'] }
                     : {}),
             };
         }

package/public/manager/src/settings/pages/components/memory-helpers.ts

@@ -62,17 +62,17 @@ function unwrapOkData(payload: unknown): unknown {
     if (!payload || typeof payload !== 'object') return payload;
     const obj = payload as Record<string, unknown>;
     if (Array.isArray(obj)) return obj;
-    if ('data' in obj) return obj.data;
+    if ('data' in obj) return obj['data'];
     return payload;
 }
 
 function safeMemoryEntry(raw: unknown): MemoryEntry | null {
     if (!raw || typeof raw !== 'object') return null;
     const r = raw as Record<string, unknown>;
-    const key = typeof r.key === 'string' ? r.key : null;
+    const key = typeof r['key'] === 'string' ? r['key'] : null;
     if (!key) return null;
-    const value = typeof r.value === 'string' ? r.value : '';
-    const source = typeof r.source === 'string' ? r.source : 'manual';
+    const value = typeof r['value'] === 'string' ? r['value'] : '';
+    const source = typeof r['source'] === 'string' ? r['source'] : 'manual';
     return { key, value, source };
 }
 

package/public/manager/src/settings/pages/mcp-helpers.ts

@@ -33,7 +33,7 @@ export function isValidServerName(name: string): boolean {
 export function normalizeMcpConfig(raw: unknown): McpConfig {
     if (!raw || typeof raw !== 'object') return { servers: {} };
     const obj = raw as Record<string, unknown>;
-    const serversRaw = obj.servers;
+    const serversRaw = obj['servers'];
     const servers: Record<string, McpServer> = {};
     if (serversRaw && typeof serversRaw === 'object' && !Array.isArray(serversRaw)) {
         for (const [name, value] of Object.entries(serversRaw as Record<string, unknown>)) {
@@ -46,20 +46,20 @@ export function normalizeMcpConfig(raw: unknown): McpConfig {
 export function normalizeServer(raw: unknown): McpServer {
     if (!raw || typeof raw !== 'object') return { command: '' };
     const r = raw as Record<string, unknown>;
-    const command = typeof r.command === 'string' ? r.command : '';
-    const args = Array.isArray(r.args)
-        ? r.args.filter((v): v is string => typeof v === 'string')
+    const command = typeof r['command'] === 'string' ? r['command'] : '';
+    const args = Array.isArray(r['args'])
+        ? r['args'].filter((v): v is string => typeof v === 'string')
         : undefined;
     const env =
-        r.env && typeof r.env === 'object' && !Array.isArray(r.env)
+        r['env'] && typeof r['env'] === 'object' && !Array.isArray(r['env'])
             ? Object.fromEntries(
-                Object.entries(r.env as Record<string, unknown>).filter(
+                Object.entries(r['env'] as Record<string, unknown>).filter(
                     (entry): entry is [string, string] =>
                         typeof entry[1] === 'string',
                 ),
             )
             : undefined;
-    const autostart = typeof r.autostart === 'boolean' ? r.autostart : undefined;
+    const autostart = typeof r['autostart'] === 'boolean' ? r['autostart'] : undefined;
     const out: McpServer = { command };
     if (args && args.length > 0) out.args = args;
     if (env && Object.keys(env).length > 0) out.env = env;

package/public/manager/src/settings/settings-client.ts

@@ -34,13 +34,14 @@ export function createSettingsClient(port: number): SettingsClient {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
         try {
-            const response = await fetch(`${base}${path}`, {
+            const fetchInit: RequestInit = {
                 method,
                 headers,
-                body: body === undefined ? undefined : JSON.stringify(body),
                 signal: init?.signal || controller.signal,
                 ...init,
-            });
+            };
+            if (body !== undefined) fetchInit.body = JSON.stringify(body);
+            const response = await fetch(`${base}${path}`, fetchInit);
             if (!response.ok) {
                 const detail = await response.text().catch(() => '');
                 throw new SettingsRequestError(method, path, response.status, detail);

package/public/manager/src/sync/IframeBridge.tsx

@@ -0,0 +1,29 @@
+import { useEffect } from 'react';
+import { publishInvalidation, type InvalidationTopic } from './invalidation-bus';
+
+const VALID_TOPICS = new Set<InvalidationTopic>(['notes', 'instances']);
+
+type IframeInvalidationMessage = {
+    type: 'dashboard.invalidate';
+    topics: InvalidationTopic[];
+    reason: string;
+};
+
+function isValid(data: unknown): data is IframeInvalidationMessage {
+    const d = data as Partial<IframeInvalidationMessage>;
+    return d?.type === 'dashboard.invalidate'
+        && Array.isArray(d.topics)
+        && d.topics.every(t => VALID_TOPICS.has(t as InvalidationTopic));
+}
+
+export function IframeBridge(): null {
+    useEffect(() => {
+        function onMessage(event: MessageEvent): void {
+            if (!isValid(event.data)) return;
+            publishInvalidation({ ...event.data, source: 'iframe' });
+        }
+        window.addEventListener('message', onMessage);
+        return () => window.removeEventListener('message', onMessage);
+    }, []);
+    return null;
+}

package/public/manager/src/sync/VisibilityBridge.tsx

@@ -0,0 +1,24 @@
+import { useEffect, useRef } from 'react';
+import { publishInvalidation } from './invalidation-bus';
+
+const MIN_STALE_MS = 30_000;
+
+export function VisibilityBridge(): null {
+    const lastRefreshRef = useRef(Date.now());
+
+    useEffect(() => {
+        function onVisible(): void {
+            if (document.visibilityState !== 'visible') return;
+            if (Date.now() - lastRefreshRef.current < MIN_STALE_MS) return;
+            lastRefreshRef.current = Date.now();
+            publishInvalidation({
+                topics: ['notes', 'instances'],
+                reason: 'visibility:tab-returned',
+                source: 'visibility',
+            });
+        }
+        document.addEventListener('visibilitychange', onVisible);
+        return () => document.removeEventListener('visibilitychange', onVisible);
+    }, []);
+    return null;
+}

package/public/manager/src/sync/invalidation-bus.ts

@@ -0,0 +1,30 @@
+export type InvalidationTopic = 'notes' | 'instances';
+
+export type InvalidationEvent = {
+    topics: InvalidationTopic[];
+    reason: string;
+    source?: 'ui' | 'iframe' | 'visibility';
+    sourceId?: string;
+};
+
+const target = new EventTarget();
+const EVENT_NAME = 'dashboard:invalidate';
+
+export function publishInvalidation(event: InvalidationEvent): void {
+    target.dispatchEvent(new CustomEvent<InvalidationEvent>(EVENT_NAME, { detail: event }));
+}
+
+export function subscribeInvalidation(
+    topic: InvalidationTopic,
+    callback: (event: InvalidationEvent) => void,
+    ignoreSourceId?: string,
+): () => void {
+    function handler(e: Event): void {
+        const detail = (e as CustomEvent<InvalidationEvent>).detail;
+        if (!detail.topics.includes(topic)) return;
+        if (ignoreSourceId && detail.sourceId === ignoreSourceId) return;
+        callback(detail);
+    }
+    target.addEventListener(EVENT_NAME, handler);
+    return () => target.removeEventListener(EVENT_NAME, handler);
+}

package/public/manager/src/sync/useInvalidationSubscription.ts

@@ -0,0 +1,19 @@
+import { useEffect, useRef } from 'react';
+import { subscribeInvalidation, type InvalidationTopic } from './invalidation-bus';
+
+export function useInvalidationSubscription(
+    topic: InvalidationTopic,
+    callback: () => void,
+    ignoreSourceId?: string,
+): void {
+    const callbackRef = useRef(callback);
+    callbackRef.current = callback;
+    const timerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
+    useEffect(() => {
+        return subscribeInvalidation(topic, () => {
+            clearTimeout(timerRef.current);
+            timerRef.current = setTimeout(() => callbackRef.current(), 100);
+        }, ignoreSourceId);
+    }, [topic, ignoreSourceId]);
+}

package/public/manager/src/types.ts

@@ -291,6 +291,20 @@ export type DashboardPutNoteRequest = {
     baseRevision?: string;
 };
 
+export type DashboardNoteAssetUploadRequest = {
+    notePath: string;
+    mime: string;
+    dataBase64: string;
+};
+
+export type DashboardNoteAssetResponse = {
+    ok: true;
+    path: string;
+    markdown: string;
+    mime: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+    size: number;
+};
+
 export type DashboardTrashNoteKind = 'file' | 'folder';
 
 export type DashboardTrashNoteResponse = {
@@ -299,3 +313,90 @@ export type DashboardTrashNoteResponse = {
     deletedTo: 'os-trash' | 'dashboard-trash';
     restoreHint?: string;
 };
+
+export type NoteLinkStatus = 'resolved' | 'missing' | 'ambiguous';
+
+export type NoteIndexWarningCode =
+    | 'frontmatter_parse_error'
+    | 'frontmatter_unsupported_value'
+    | 'invalid_wikilink_target'
+    | 'note_file_too_large'
+    | 'note_symlink_skipped';
+
+export type NoteIndexWarning = {
+    code: NoteIndexWarningCode;
+    path: string;
+    message: string;
+    line?: number;
+    column?: number;
+};
+
+export type NoteLinkReason = 'not_found' | 'invalid_target' | 'ambiguous';
+
+export type NoteLinkRef = {
+    sourcePath: string;
+    raw: string;
+    target: string;
+    displayText?: string;
+    heading?: string;
+    line: number;
+    column: number;
+    startOffset: number;
+    endOffset: number;
+    status: NoteLinkStatus;
+    resolvedPath?: string;
+    candidatePaths?: string[];
+    reason?: NoteLinkReason;
+};
+
+export type NoteMetadata = {
+    path: string;
+    title: string;
+    aliases: string[];
+    tags: string[];
+    created?: string;
+    mtimeMs: number;
+    size: number;
+    revision: string;
+    frontmatterError?: string;
+};
+
+export type NoteGraphNode = {
+    id: string;
+    title: string;
+    kind: 'note' | 'missing' | 'ambiguous';
+    path?: string;
+    candidatePaths?: string[];
+};
+
+export type NoteGraphEdge = {
+    source: string;
+    target: string;
+    raw: string;
+    status: NoteLinkStatus;
+    resolvedPath?: string;
+};
+
+export type VaultIndexSnapshot = {
+    version: number;
+    notes: NoteMetadata[];
+    outgoingLinks: Record<string, NoteLinkRef[]>;
+    backlinks: Record<string, NoteLinkRef[]>;
+    unresolvedLinks: NoteLinkRef[];
+    graph: { nodes: NoteGraphNode[]; edges: NoteGraphEdge[] };
+    errors: NoteIndexWarning[];
+};
+
+export type NotesCapability = {
+    available: boolean;
+    version?: string;
+    command?: string;
+    reason?: string;
+};
+
+export type DashboardNotesCapabilities = {
+    ripgrep: NotesCapability;
+    git: NotesCapability;
+    fileWatching: NotesCapability & { provider?: 'fs.watch' | 'watcher' };
+    pdf: NotesCapability;
+};

package/scripts/check-strict-baseline.mjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+// @file scripts/check-strict-baseline.mjs
+// Strict-migration regression gate (AST-aware).
+//
+// Per R2.2 (devlog/_plan/strict-migration/07-pro-review-r2.md), this scanner
+// uses the TypeScript Compiler API to walk source files and count AST nodes
+// of kind `AnyKeyword` plus any-typed `TypeReference` (Array<any>, Promise<any>,
+// Record<string, any>, etc.). Comments and string literals are automatically
+// ignored because they are not type-position AST nodes.
+//
+// Two markers per R2.2.1:
+//   @strict-debt(P##)        — temporary, must be cleared by phase P##
+//   @strict-allow-any(<reason>) — permanently allowed, counted separately
+//
+// Reads docs/migration/strict-baseline.md for frozen counts and exits 1 if
+// any tracked directory's live count exceeds the baseline.
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+const REPO_ROOT = process.env.STRICT_BASELINE_ROOT || fileURLToPath(new URL('..', import.meta.url));
+const BASELINE_PATH = join(REPO_ROOT, 'docs/migration/strict-baseline.md');
+
+const TRACKED_DIRS = ['src', 'bin', 'lib', 'public/js', 'public/manager/src', 'scripts', 'server.ts', 'types'];
+const STRICT_DEBT_SCAN_PATHS = ['src', 'bin', 'lib', 'scripts', 'server.ts', 'public', 'types'];
+const EXCLUDE_DIR_NAMES = new Set([
+    'node_modules', 'dist', 'build', '.git', 'coverage', '__snapshots__',
+]);
+
+function isTypeScriptFile(file) {
+    return file.endsWith('.ts') || file.endsWith('.tsx');
+}
+
+function* walk(dir) {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    for (const e of entries) {
+        if (EXCLUDE_DIR_NAMES.has(e.name)) continue;
+        const full = join(dir, e.name);
+        if (e.isDirectory()) yield* walk(full);
+        else if (e.isFile() && isTypeScriptFile(full)) yield full;
+    }
+}
+
+function* filesForPath(absPath) {
+    let stat;
+    try { stat = statSync(absPath); } catch { return; }
+    if (stat.isDirectory()) {
+        yield* walk(absPath);
+        return;
+    }
+    if (stat.isFile() && isTypeScriptFile(absPath)) yield absPath;
+}
+
+const ANY_TYPE_REF_NAMES = new Set([
+    'Array', 'Promise', 'Record', 'ReadonlyArray', 'Map', 'Set', 'Partial',
+    'Required', 'Readonly', 'Pick', 'Omit', 'ReadonlyMap', 'ReadonlySet',
+]);
+
+function isAnyKeyword(node) {
+    return ts.isToken(node) && node.kind === ts.SyntaxKind.AnyKeyword;
+}
+
+// Detect type reference whose own type-arguments include `any`, e.g. Record<string, any>.
+function typeArgsContainAny(node) {
+    if (!ts.isTypeReferenceNode(node)) return false;
+    const args = node.typeArguments;
+    if (!args || args.length === 0) return false;
+    return args.some((a) => a.kind === ts.SyntaxKind.AnyKeyword);
+}
+
+function leadingMarkerOnLine(src, pos) {
+    // Look back to the start of the line that contains `pos`, then look at
+    // the lines immediately before for `// @strict-debt(...)` or
+    // `// @strict-allow-any(...)`. Allow up to 3 lines of preceding context.
+    const before = src.slice(0, pos);
+    const idx = before.lastIndexOf('\n');
+    const lineStart = idx + 1;
+    const lineText = src.slice(lineStart, src.indexOf('\n', pos) >= 0 ? src.indexOf('\n', pos) : src.length);
+
+    if (/@strict-(debt|allow-any)\b/.test(lineText)) {
+        return /@strict-debt\b/.test(lineText) ? 'debt' : 'allow';
+    }
+
+    // check up to 3 lines above (whitespace-only between also fine)
+    let cursor = lineStart;
+    for (let i = 0; i < 3; i++) {
+        if (cursor <= 0) break;
+        const prevEnd = cursor - 1;
+        const prevStart = src.lastIndexOf('\n', prevEnd - 1) + 1;
+        const prev = src.slice(prevStart, prevEnd);
+        if (/@strict-debt\b/.test(prev)) return 'debt';
+        if (/@strict-allow-any\b/.test(prev)) return 'allow';
+        if (prev.trim() !== '' && !/^\s*\/\//.test(prev)) break;
+        cursor = prevStart;
+    }
+    return null;
+}
+
+function scanText(src, filename = 'inline.ts') {
+    const sf = ts.createSourceFile(filename, src, ts.ScriptTarget.Latest, /*setParentNodes*/ true, filename.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    let any = 0;
+    let debt = 0;
+    let allow = 0;
+    function visit(node) {
+        if (isAnyKeyword(node)) {
+            const marker = leadingMarkerOnLine(src, node.getStart(sf));
+            if (marker === 'debt') debt++;
+            else if (marker === 'allow') allow++;
+            else any++;
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return { any, debt, allow };
+}
+
+function scanFile(file) {
+    const src = readFileSync(file, 'utf8');
+    return scanText(src, file);
+}
+
+function countDir(absDir) {
+    const result = { any: 0, debt: 0, allow: 0 };
+    for (const file of filesForPath(absDir)) {
+        const r = scanFile(file);
+        result.any += r.any;
+        result.debt += r.debt;
+        result.allow += r.allow;
+    }
+    return result;
+}
+
+function findStrictDebtMarkers(absDir) {
+    const hits = [];
+    for (const file of filesForPath(absDir)) {
+        const src = readFileSync(file, 'utf8');
+        const lines = src.split(/\r?\n/);
+        lines.forEach((line, idx) => {
+            if (line.includes('@strict-debt')) hits.push(`${file}:${idx + 1}`);
+        });
+    }
+    return hits;
+}
+
+function runTypecheck(args) {
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const result = spawnSync(npx, args, {
+        cwd: REPO_ROOT,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+        ok: result.status === 0,
+        status: result.status,
+        output: `${result.stdout || ''}${result.stderr || ''}`.trim(),
+    };
+}
+
+function parseBaseline(text) {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((l) => /^##\s+any-shapes baseline\b/i.test(l));
+    if (start < 0) throw new Error('baseline section "## any-shapes baseline" not found');
+    const out = {};
+    for (let i = start + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('## ')) break;
+        if (!line.startsWith('|')) continue;
+        if (/^\|[\s\-:|]+\|$/.test(line)) continue;
+        const cells = line.split('|').slice(1, -1).map((c) => c.trim());
+        if (cells.length !== 4) continue;
+        if (cells[0].toLowerCase() === 'dir') continue;
+        const [dir, any, debt, allow] = cells;
+        out[dir] = { any: Number(any), debt: Number(debt), allow: Number(allow) };
+    }
+    if (Object.keys(out).length === 0) {
+        throw new Error('baseline table parsed empty — check column count and separator');
+    }
+    return out;
+}
+
+function fmt(dir, c) { return `| ${dir} | ${c.any} | ${c.debt} | ${c.allow} |`; }
+
+function main() {
+    const baselineText = readFileSync(BASELINE_PATH, 'utf8');
+    const baseline = parseBaseline(baselineText);
+
+    const live = {};
+    for (const dir of TRACKED_DIRS) live[dir] = countDir(join(REPO_ROOT, dir));
+
+    const regressions = [];
+    const debtMarkerHits = [];
+    for (const dir of TRACKED_DIRS) {
+        const b = baseline[dir];
+        const l = live[dir];
+        if (!b) { regressions.push(`baseline missing for tracked dir "${dir}"`); continue; }
+        if (l.any > b.any) regressions.push(`${dir}.any: live=${l.any} > baseline=${b.any} (+${l.any - b.any})`);
+        if (l.debt > b.debt) regressions.push(`${dir}.debt: live=${l.debt} > baseline=${b.debt} (+${l.debt - b.debt})`);
+        // allow can grow — permanent contracts; only flag if doc forbids
+    }
+    for (const path of STRICT_DEBT_SCAN_PATHS) {
+        debtMarkerHits.push(...findStrictDebtMarkers(join(REPO_ROOT, path)));
+    }
+    if (debtMarkerHits.length > 0) {
+        regressions.push(`@strict-debt markers are forbidden post-P20: ${debtMarkerHits.join(', ')}`);
+    }
+
+    const header = '| dir | any | debt | allow |';
+    const sep    = '|-----|----:|-----:|------:|';
+    console.log('## strict-baseline live snapshot');
+    console.log(header); console.log(sep);
+    for (const dir of TRACKED_DIRS) console.log(fmt(dir, live[dir]));
+    console.log('');
+    console.log('## strict-baseline baseline (frozen)');
+    console.log(header); console.log(sep);
+    for (const dir of TRACKED_DIRS) {
+        const b = baseline[dir] ?? { any: '—', debt: '—', allow: '—' };
+        console.log(fmt(dir, b));
+    }
+    console.log('');
+
+    console.log('## strict-baseline typecheck gates');
+    const rootTypecheck = runTypecheck(['tsc', '--noEmit']);
+    console.log(`root: ${rootTypecheck.ok ? 'ok' : `fail (${rootTypecheck.status ?? 'unknown'})`}`);
+    if (!rootTypecheck.ok) regressions.push(`root typecheck failed:\n${rootTypecheck.output}`);
+    const frontendTypecheck = runTypecheck(['tsc', '--noEmit', '-p', 'tsconfig.frontend.json']);
+    console.log(`frontend: ${frontendTypecheck.ok ? 'ok' : `fail (${frontendTypecheck.status ?? 'unknown'})`}`);
+    if (!frontendTypecheck.ok) regressions.push(`frontend typecheck failed:\n${frontendTypecheck.output}`);
+    console.log('');
+
+    if (regressions.length > 0) {
+        console.error('❌ strict-baseline regression detected:');
+        for (const r of regressions) console.error('  - ' + r);
+        console.error('');
+        console.error('If this regression is intentional (a phase plan accepted it),');
+        console.error('lower the baseline in docs/migration/strict-baseline.md in the SAME PR.');
+        console.error('To temporarily exempt a single occurrence, annotate it with one of:');
+        console.error('  // @strict-debt(P##)        — must be cleared by phase P##');
+        console.error('  // @strict-allow-any(<reason>) — permanent contract');
+        process.exit(1);
+    }
+    console.log('✅ strict-baseline OK (no regressions in tracked directories).');
+}
+
+// Run as CLI when executed directly, not when imported by tests.
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}
+
+// Exported for unit tests (R2.2.2). Not part of CLI surface.
+export { scanFile, scanText, parseBaseline, countDir, TRACKED_DIRS };