@notis_ai/cli 0.2.1 → 0.2.3

package/template/packages/{notis-sdk → sdk}/src/hooks/useTool.ts

@@ -3,27 +3,42 @@
 import { useCallback, useState } from 'react';
 import { useNotisRuntime } from '../provider';
 
-interface UseToolResult {
-  call: (args?: Record<string, unknown>) => Promise<unknown>;
+type ToolArguments = Record<string, unknown>;
+
+type ToolCall<TArgs extends ToolArguments | undefined, TResult> = undefined extends TArgs
+  ? (args?: Exclude<TArgs, undefined>) => Promise<TResult>
+  : (args: TArgs) => Promise<TResult>;
+
+export interface ToolCallState {
   loading: boolean;
   error: Error | null;
 }
 
+export interface UseToolResult<
+  TArgs extends ToolArguments | undefined = ToolArguments | undefined,
+  TResult = unknown,
+> extends ToolCallState {
+  call: ToolCall<TArgs, TResult>;
+}
+
 /**
  * Call a specific Notis tool by name.
  *
  * ```tsx
- * const { call, loading } = useTool('notis_web_search');
+ * const { call, loading } = useTool('LOCAL_NOTIS_WEB_SEARCH');
  * const result = await call({ query: 'latest news' });
  * ```
  */
-export function useTool(toolName: string): UseToolResult {
+export function useTool<
+  TArgs extends ToolArguments | undefined = ToolArguments | undefined,
+  TResult = unknown,
+>(toolName: string): UseToolResult<TArgs, TResult> {
   const runtime = useNotisRuntime();
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
   const call = useCallback(
-    async (args?: Record<string, unknown>): Promise<unknown> => {
+    async (args?: ToolArguments): Promise<TResult> => {
       if (!runtime) {
         throw new Error('Notis runtime not available. Ensure NotisProvider is mounted.');
       }
@@ -32,7 +47,7 @@ export function useTool(toolName: string): UseToolResult {
       setError(null);
 
       try {
-        const result = await runtime.callTool(toolName, args);
+        const result = await runtime.callTool<TResult>(toolName, args);
         return result;
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
@@ -43,7 +58,7 @@ export function useTool(toolName: string): UseToolResult {
       }
     },
     [runtime, toolName],
-  );
+  ) as ToolCall<TArgs, TResult>;
 
   return { call, loading, error };
 }

package/template/packages/{notis-sdk → sdk}/src/hooks/useUpsertDocument.ts

@@ -18,14 +18,6 @@ interface UseUpsertDocumentResult {
   error: Error | null;
 }
 
-/**
- * Create or update a document in a Notis database.
- *
- * ```tsx
- * const { upsert, loading } = useUpsertDocument();
- * await upsert({ databaseSlug: 'tasks', title: 'New task', properties: { status: 'Open' } });
- * ```
- */
 export function useUpsertDocument(): UseUpsertDocumentResult {
   const runtime = useNotisRuntime();
   const [loading, setLoading] = useState(false);

package/template/packages/{notis-sdk → sdk}/src/index.ts

@@ -12,15 +12,13 @@ export { NotisProvider, useNotisRuntime } from './provider';
 // Hooks
 export { useNotis } from './hooks/useNotis';
 export { useDatabase } from './hooks/useDatabase';
-export { useDocument } from './hooks/useDocument';
 export { useUpsertDocument } from './hooks/useUpsertDocument';
 export { useTool } from './hooks/useTool';
+export type { ToolCallState, UseToolResult } from './hooks/useTool';
 export { useTools } from './hooks/useTools';
-export { useCollectionItems } from './hooks/useCollectionItem';
 export { useNotisNavigation } from './hooks/useNotisNavigation';
 export { useTopBarSearch } from './hooks/useTopBarSearch';
 export { useBackend } from './hooks/useBackend';
-export { useAppState } from './hooks/useAppState';
 export { useMultiSelect } from './hooks/useMultiSelect';
 
 // Multi-select components
@@ -39,18 +37,6 @@ export type {
 export type { MultiSelectCheckboxProps } from './components/MultiSelectCheckbox';
 export type { MultiSelectDragOverlayProps } from './components/MultiSelectDragOverlay';
 
-// Property extraction helpers
-export {
-  extractText,
-  extractSelect,
-  extractDate,
-  extractNumber,
-  extractCheckbox,
-  extractMultiSelect,
-  extractRelation,
-  docTitle,
-} from './helpers';
-
 // Types (re-exported for convenience)
 export type {
   AppDescriptor,
@@ -64,4 +50,5 @@ export type {
   QueryFilter,
   RouteDescriptor,
   ToolDescriptor,
+  ToolInputSchema,
 } from './runtime';

package/template/packages/{notis-sdk → sdk}/src/provider.tsx

@@ -36,7 +36,7 @@ export function NotisProvider({ children, runtime }: { children: ReactNode; runt
 
 /**
  * Returns the raw NotisRuntime or null if not yet available.
- * Prefer the typed hooks (useDatabase, useTool, etc.) over this.
+ * Prefer the typed hooks (useTool, useNotis, etc.) over this.
  */
 export function useNotisRuntime(): NotisRuntime | null {
   return useContext(NotisContext);

package/template/packages/{notis-sdk → sdk}/src/runtime.ts

@@ -4,7 +4,7 @@
  * `NotisProvider` when the app is rendered.
  *
  * App code should never reach for globals. Use the hooks from `@notis/sdk`
- * (useDatabase, useTool, etc.) which read from the NotisProvider context.
+ * (useTool, useNotis, etc.) which read from the NotisProvider context.
  */
 
 // ---------------------------------------------------------------------------
@@ -44,10 +44,12 @@ export interface DocumentRecord {
 // Tool types
 // ---------------------------------------------------------------------------
 
+export type ToolInputSchema = Record<string, unknown>;
+
 export interface ToolDescriptor {
   name: string;
   description?: string;
-  input_schema?: Record<string, unknown>;
+  inputSchema?: ToolInputSchema;
 }
 
 // ---------------------------------------------------------------------------
@@ -82,11 +84,6 @@ export interface CollectionItemDetail extends CollectionItem {
   properties: Record<string, unknown>;
 }
 
-export interface CollectionTreeItem extends CollectionItem {
-  parent_id: string | null;
-  has_children: boolean;
-}
-
 // ---------------------------------------------------------------------------
 // App descriptor
 // ---------------------------------------------------------------------------
@@ -98,10 +95,6 @@ export interface AppDescriptor {
   description?: string | null;
 }
 
-// ---------------------------------------------------------------------------
-// Query types
-// ---------------------------------------------------------------------------
-
 export interface QueryFilter {
   filters?: Array<{
     property: string;
@@ -144,7 +137,7 @@ export interface NotisRuntime {
   setTopBarSearchLoading?: (loading: boolean) => void;
 
   listTools(): Promise<ToolDescriptor[]>;
-  callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+  callTool<TResult = unknown>(name: string, args?: Record<string, unknown>): Promise<TResult>;
 
   queryDatabase(args: {
     databaseSlug: string;
@@ -152,10 +145,6 @@ export interface NotisRuntime {
     offset?: number;
   }): Promise<{ documents: DocumentRecord[] }>;
 
-  getDocument(args: {
-    documentId: string;
-  }): Promise<DocumentRecord>;
-
   upsertDocument(args: {
     databaseSlug: string;
     documentId?: string;
@@ -164,16 +153,6 @@ export interface NotisRuntime {
     contentBlocknote?: Array<Record<string, unknown>> | null;
   }): Promise<{ status: string; document: DocumentRecord }>;
 
-  listCollectionItems(args?: {
-    databaseSlug?: string;
-    pageSize?: number;
-  }): Promise<{ items: CollectionItem[] }>;
-
-  listCollectionTree?(args?: {
-    databaseSlug?: string;
-    pageSize?: number;
-  }): Promise<{ items: CollectionTreeItem[] }>;
-
   request(path: string, options?: {
     method?: string;
     headers?: Record<string, string>;

package/src/command-specs/auth.js

@@ -1,178 +0,0 @@
-import { CliError, EXIT_CODES } from '../runtime/errors.js';
-import {
-  clearStoredJwt,
-  probeAuth,
-  promptForJwt,
-  updateStoredProfile,
-} from './helpers.js';
-
-async function authLoginHandler(ctx) {
-  let jwt = ctx.options.jwt || process.env.NOTIS_JWT;
-  if (!jwt) {
-    if (ctx.runtime.nonInteractive) {
-      throw new CliError({
-        code: 'auth_missing',
-        message: `No JWT configured for profile ${ctx.runtime.profileName}`,
-        exitCode: EXIT_CODES.auth,
-        hints: [
-          {
-            command: 'notis auth login --jwt <token>',
-            reason: 'Provide a token explicitly in non-interactive mode',
-          },
-        ],
-      });
-    }
-    jwt = await promptForJwt();
-  }
-
-  updateStoredProfile({
-    profileName: ctx.runtime.profileName,
-    jwt,
-    apiBase: ctx.globalOptions.apiBase,
-    setCurrent: true,
-  });
-
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: {
-      profile: ctx.runtime.profileName,
-      api_base: ctx.globalOptions.apiBase || ctx.runtime.apiBase,
-    },
-    humanSummary: `Stored credentials for profile ${ctx.runtime.profileName}`,
-    hints: [
-      { command: 'notis whoami', reason: 'Verify your identity and available toolkits' },
-    ],
-    meta: { mutating: true },
-  });
-}
-
-async function authLogoutHandler(ctx) {
-  clearStoredJwt(ctx.runtime.profileName);
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: { profile: ctx.runtime.profileName },
-    humanSummary: `Removed stored JWT for profile ${ctx.runtime.profileName}`,
-    meta: { mutating: true },
-  });
-}
-
-async function authStatusHandler(ctx) {
-  const hasJwt = Boolean(ctx.runtime.jwt);
-  let verified = false;
-  let toolkits = [];
-  if (hasJwt && ctx.options.verify) {
-    const payload = await probeAuth(ctx.runtime);
-    toolkits = payload.toolkits || [];
-    verified = true;
-  }
-
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: {
-      profile: ctx.runtime.profileName,
-      api_base: ctx.runtime.apiBase,
-      has_jwt: hasJwt,
-      verified,
-      toolkits,
-    },
-    humanSummary: hasJwt
-      ? `Profile ${ctx.runtime.profileName} is configured`
-      : `Profile ${ctx.runtime.profileName} is missing a JWT`,
-    hints: hasJwt
-      ? []
-      : [{ command: 'notis auth login --jwt <token>', reason: 'Configure credentials for this profile' }],
-    meta: { mutating: false },
-  });
-}
-
-export const authCommandSpecs = [
-  {
-    command_path: ['auth', 'login'],
-    summary: 'Store credentials for a named CLI profile.',
-    when_to_use: 'Use this before authenticated commands, especially in fresh environments or CI profiles.',
-    args_schema: {
-      arguments: [],
-      options: [
-        { flags: '--jwt <token>', description: 'JWT token to store for the profile.' },
-      ],
-    },
-    examples: ['notis auth login --jwt <token>', 'notis auth login --profile staging --api-base http://localhost:3001'],
-    output_schema: 'Returns the active profile name and API base.',
-    mutates: true,
-    idempotent: true,
-    require_auth: false,
-    related_commands: ['notis auth status --verify', 'notis auth logout'],
-    backend_call: { type: 'local' },
-    handler: authLoginHandler,
-  },
-  {
-    command_path: ['auth', 'logout'],
-    summary: 'Remove the stored JWT for the active profile.',
-    when_to_use: 'Use this to clear local credentials without touching other profiles.',
-    args_schema: { arguments: [], options: [] },
-    examples: ['notis auth logout', 'notis auth logout --profile staging'],
-    output_schema: 'Returns the profile that was updated.',
-    mutates: true,
-    idempotent: true,
-    require_auth: false,
-    related_commands: ['notis auth login --jwt <token>', 'notis auth status'],
-    backend_call: { type: 'local' },
-    handler: authLogoutHandler,
-  },
-  {
-    command_path: ['auth', 'status'],
-    summary: 'Inspect local auth configuration and optionally verify it against the API.',
-    when_to_use: 'Use this before automating commands to confirm the active profile and token health.',
-    args_schema: {
-      arguments: [],
-      options: [
-        { flags: '--verify', description: 'Perform a live authenticated roundtrip to the API.' },
-      ],
-    },
-    examples: ['notis auth status', 'notis auth status --verify --json'],
-    output_schema: 'Returns profile, api_base, local auth presence, and optional verification data.',
-    mutates: false,
-    idempotent: true,
-    require_auth: false,
-    related_commands: ['notis doctor', 'notis auth login --jwt <token>'],
-    backend_call: { type: 'notis_find_toolkits' },
-    handler: authStatusHandler,
-  },
-  {
-    command_path: ['login'],
-    display_name: 'login',
-    summary: 'Deprecated alias for `notis auth login`.',
-    when_to_use: 'Use only for backward compatibility with older scripts.',
-    args_schema: {
-      arguments: [],
-      options: [
-        { flags: '--jwt <token>', description: 'JWT token to store for the profile.' },
-      ],
-    },
-    examples: ['notis login --jwt <token>'],
-    output_schema: 'Same output as `notis auth login`.',
-    mutates: true,
-    idempotent: true,
-    require_auth: false,
-    related_commands: ['notis auth login --jwt <token>'],
-    backend_call: { type: 'local', alias_for: 'auth login' },
-    deprecated_alias_for: 'notis auth login',
-    handler: authLoginHandler,
-  },
-  {
-    command_path: ['logout'],
-    display_name: 'logout',
-    summary: 'Deprecated alias for `notis auth logout`.',
-    when_to_use: 'Use only for backward compatibility with older scripts.',
-    args_schema: { arguments: [], options: [] },
-    examples: ['notis logout'],
-    output_schema: 'Same output as `notis auth logout`.',
-    mutates: true,
-    idempotent: true,
-    require_auth: false,
-    related_commands: ['notis auth logout'],
-    backend_call: { type: 'local', alias_for: 'auth logout' },
-    deprecated_alias_for: 'notis auth logout',
-    handler: authLogoutHandler,
-  },
-];

package/src/command-specs/db.js

@@ -1,163 +0,0 @@
-import { formatTable } from '../runtime/output.js';
-import { nextIdempotencyKey, parseMaybeJson, runToolCommand } from './helpers.js';
-
-async function dbListHandler(ctx) {
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_list_databases',
-  });
-  const databases = result.payload.databases || [];
-  const firstSlug = databases[0]?.slug;
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: { databases },
-    humanSummary: databases.length ? `Found ${databases.length} databases` : 'No databases found.',
-    hints: firstSlug
-      ? [{ command: `notis db query ${firstSlug}`, reason: 'Query this database' }]
-      : [{ command: 'notis db upsert --operation create --title "My DB"', reason: 'Create a new database' }],
-    renderHuman: () =>
-      databases.length
-        ? formatTable(databases, [
-            { label: 'ID', value: (database) => database.id || '' },
-            { label: 'Name', value: (database) => database.name || 'Untitled' },
-            { label: 'Slug', value: (database) => database.slug || '-' },
-          ])
-        : 'No databases found.',
-  });
-}
-
-async function dbUpsertHandler(ctx) {
-  const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
-  const payload = {
-    operation: ctx.options.operation,
-  };
-  if (ctx.options.databaseId) {
-    payload.database_id = ctx.options.databaseId;
-  }
-  if (ctx.options.title) {
-    payload.title = ctx.options.title;
-  }
-  if (ctx.options.description) {
-    payload.description = ctx.options.description;
-  }
-  if (ctx.options.icon) {
-    const v = ctx.options.icon;
-    payload.icon = v.startsWith('lucide:') ? v : `lucide:${v}`;
-  }
-  if (ctx.options.properties) {
-    payload.properties = parseMaybeJson(ctx.options.properties, 'properties');
-  }
-
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_upsert_database',
-    arguments_: payload,
-    mutating: true,
-    idempotencyKey,
-  });
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: result.payload,
-    humanSummary: `Database ${ctx.options.operation} completed`,
-    meta: { mutating: true, idempotency_key: idempotencyKey || null },
-  });
-}
-
-async function dbQueryHandler(ctx) {
-  const query = {};
-  if (ctx.options.filter) {
-    query.filter = parseMaybeJson(ctx.options.filter, 'filter');
-  }
-  if (ctx.options.sort) {
-    const parsedSorts = parseMaybeJson(ctx.options.sort, 'sort');
-    query.sorts = Array.isArray(parsedSorts) ? parsedSorts : [parsedSorts];
-  }
-  if (ctx.options.pageSize) {
-    query.page_size = Number.parseInt(ctx.options.pageSize, 10);
-  }
-
-  const payload = {
-    database_slug: ctx.args.databaseSlug,
-    query,
-  };
-  if (ctx.options.offset) {
-    payload.offset = Number.parseInt(ctx.options.offset, 10);
-  }
-  if (ctx.options.cursor) {
-    payload.start_cursor = ctx.options.cursor;
-  }
-
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_query',
-    arguments_: payload,
-  });
-
-  return ctx.output.emitSuccess({
-    command: ctx.spec.command_path.join(' '),
-    data: result.payload,
-    humanSummary: `Queried database ${ctx.args.databaseSlug}`,
-    renderHuman: () => JSON.stringify(result.payload, null, 2),
-  });
-}
-
-export const dbCommandSpecs = [
-  {
-    command_path: ['db', 'list'],
-    summary: 'List native Notis databases.',
-    when_to_use: 'Use this to find database ids and slugs before querying or updating schemas.',
-    args_schema: { arguments: [], options: [] },
-    examples: ['notis db list', 'notis db list --json'],
-    output_schema: 'Returns an array of native database records.',
-    mutates: false,
-    idempotent: true,
-    related_commands: ['notis db query <database-slug>', 'notis db upsert'],
-    backend_call: { type: 'tool', name: 'notis_list_databases' },
-    handler: dbListHandler,
-  },
-  {
-    command_path: ['db', 'upsert'],
-    summary: 'Create or update a native database schema.',
-    when_to_use: 'Use this when you need to provision a new database or adjust an existing schema.',
-    args_schema: {
-      arguments: [],
-      options: [
-        { flags: '--operation <create|update>', description: 'Create a new database or update an existing one.' },
-        { flags: '--database-id <id>', description: 'Database id for update operations.' },
-        { flags: '--title <text>', description: 'Database title.' },
-        { flags: '--description <text>', description: 'Database description.' },
-        { flags: '--icon <lucide-icon-name>', description: 'Database icon (Lucide icon name, e.g. database).' },
-        { flags: '--properties <json>', description: 'JSON array of property definitions.' },
-      ],
-    },
-    examples: ['notis db upsert --operation create --title "Tasks"', 'notis db upsert --operation update --database-id db_123 --title "Tasks V2"'],
-    output_schema: 'Returns the backend database upsert payload.',
-    mutates: true,
-    idempotent: true,
-    related_commands: ['notis db list', 'notis db query <database-slug>'],
-    backend_call: { type: 'tool', name: 'notis_upsert_database' },
-    handler: dbUpsertHandler,
-  },
-  {
-    command_path: ['db', 'query'],
-    summary: 'Run a structured query against a native Notis database.',
-    when_to_use: 'Use this when the database slug is known and you need direct filters, sorts, or pagination.',
-    args_schema: {
-      arguments: [{ token: '<database-slug>', description: 'Slug of the native database to query.' }],
-      options: [
-        { flags: '--filter <json>', description: 'Structured query filter JSON.' },
-        { flags: '--sort <json>', description: 'Sort JSON object or array.' },
-        { flags: '--page-size <n>', description: 'Page size between 1 and 100.' },
-        { flags: '--offset <n>', description: 'Zero-based offset.' },
-        { flags: '--cursor <value>', description: 'Pagination cursor alias for next_offset.' },
-      ],
-    },
-    examples: ['notis db query tasks --page-size 50', 'notis db query tasks --filter \'{"property":"Status"}\''],
-    output_schema: 'Returns the native database query payload from `notis_query`.',
-    mutates: false,
-    idempotent: true,
-    related_commands: ['notis db list', 'notis db upsert'],
-    backend_call: { type: 'tool', name: 'notis_query' },
-    handler: dbQueryHandler,
-  },
-];

package/template/packages/notis-sdk/src/helpers.ts

@@ -1,131 +0,0 @@
-/**
- * Property extraction helpers for Notis DocumentRecord properties.
- *
- * Document properties come back in Notion-style nested shapes. These helpers
- * normalize them into simple JS values regardless of the shape.
- */
-
-import type { DocumentRecord } from './runtime';
-
-type Obj = Record<string, unknown>;
-
-/** Extract a string from a title, rich_text, or plain text property. */
-export function extractText(val: unknown): string {
-  if (typeof val === 'string') return val;
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (typeof obj.content === 'string') return obj.content;
-    if (typeof obj.plain_text === 'string') return obj.plain_text;
-    if (Array.isArray(obj.title)) {
-      return obj.title.map((t: Obj) => extractText(t?.text || t)).join('');
-    }
-    if (Array.isArray(obj.rich_text)) {
-      return obj.rich_text.map((t: Obj) => extractText(t?.text || t)).join('');
-    }
-    if (obj.text) return extractText(obj.text);
-  }
-  return '';
-}
-
-/** Extract a string from a select or status property. */
-export function extractSelect(val: unknown): string {
-  if (typeof val === 'string') return val;
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (obj.select && typeof obj.select === 'object') {
-      return (obj.select as Obj).name as string || '';
-    }
-    if (obj.status && typeof obj.status === 'object') {
-      return (obj.status as Obj).name as string || '';
-    }
-    if (typeof obj.name === 'string') return obj.name;
-  }
-  return '';
-}
-
-/** Extract a date string from a date property. */
-export function extractDate(val: unknown): string {
-  if (typeof val === 'string') return val;
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (obj.date && typeof obj.date === 'object') {
-      return (obj.date as Obj).start as string || '';
-    }
-    if (typeof obj.start === 'string') return obj.start;
-  }
-  return '';
-}
-
-/** Extract a number from a number property. */
-export function extractNumber(val: unknown): number | null {
-  if (typeof val === 'number') return val;
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (typeof obj.number === 'number') return obj.number;
-  }
-  return null;
-}
-
-/** Extract a boolean from a checkbox property. */
-export function extractCheckbox(val: unknown): boolean {
-  if (typeof val === 'boolean') return val;
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (typeof obj.checkbox === 'boolean') return obj.checkbox;
-  }
-  return false;
-}
-
-/** Extract multi-select values as a string array. */
-export function extractMultiSelect(val: unknown): string[] {
-  if (Array.isArray(val)) {
-    return val
-      .map((v) => {
-        if (typeof v === 'string') return v;
-        if (v && typeof v === 'object' && typeof (v as Obj).name === 'string') return (v as Obj).name as string;
-        return '';
-      })
-      .filter(Boolean);
-  }
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (Array.isArray(obj.multi_select)) return extractMultiSelect(obj.multi_select);
-  }
-  if (typeof val === 'string' && val) return [val];
-  return [];
-}
-
-/** Extract relation IDs from a relation property. */
-export function extractRelation(val: unknown): string[] {
-  if (Array.isArray(val)) {
-    return val
-      .map((v) => {
-        if (typeof v === 'string') return v;
-        if (v && typeof v === 'object' && typeof (v as Obj).id === 'string') return (v as Obj).id as string;
-        return '';
-      })
-      .filter(Boolean);
-  }
-  if (val && typeof val === 'object') {
-    const obj = val as Obj;
-    if (Array.isArray(obj.relation)) return extractRelation(obj.relation);
-  }
-  if (typeof val === 'string' && val) return [val];
-  return [];
-}
-
-/**
- * Extract display title from a document. Falls back through several property
- * names and shapes to find a human-readable title.
- */
-export function docTitle(doc: DocumentRecord): string {
-  const t = doc.title;
-  if (t && !/^[0-9a-f]{8}-[0-9a-f]{4}/.test(t)) return t;
-  const p = doc.properties || {};
-  const name = p.Name ?? p.name ?? p.Title ?? p.title;
-  if (name) {
-    const extracted = extractText(name);
-    if (extracted) return extracted;
-  }
-  return t || 'Untitled';
-}