@notis_ai/cli 0.2.1 → 0.2.2

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';
-}

package/template/packages/notis-sdk/src/hooks/useAppState.ts

@@ -1,50 +0,0 @@
-'use client';
-
-import { useCallback, useState } from 'react';
-import { useNotisRuntime } from '../provider';
-
-/**
- * Persist app-level state per user per app using localStorage.
- *
- * ```tsx
- * const [order, setOrder] = useAppState<string[]>('task-order', []);
- * ```
- *
- * State is scoped by `app.id` so different apps don't collide.
- * Falls back to defaultValue when localStorage is unavailable.
- */
-export function useAppState<T>(key: string, defaultValue: T): [T, (value: T | ((prev: T) => T)) => void] {
-  const runtime = useNotisRuntime();
-  const appId = runtime?.app?.id || '_unknown';
-  const storageKey = `notis-app-state:${appId}:${key}`;
-
-  const [value, setValueInternal] = useState<T>(() => {
-    if (typeof window === 'undefined') return defaultValue;
-    try {
-      const stored = localStorage.getItem(storageKey);
-      if (stored !== null) return JSON.parse(stored) as T;
-    } catch {
-      // Ignore parse errors or storage unavailable
-    }
-    return defaultValue;
-  });
-
-  const setValue = useCallback(
-    (newValue: T | ((prev: T) => T)) => {
-      setValueInternal((prev) => {
-        const resolved = typeof newValue === 'function'
-          ? (newValue as (prev: T) => T)(prev)
-          : newValue;
-        try {
-          localStorage.setItem(storageKey, JSON.stringify(resolved));
-        } catch {
-          // Ignore quota errors
-        }
-        return resolved;
-      });
-    },
-    [storageKey],
-  );
-
-  return [value, setValue];
-}

package/template/packages/notis-sdk/src/hooks/useCollectionItem.ts

@@ -1,58 +0,0 @@
-'use client';
-
-import { useEffect, useState } from 'react';
-import { useNotisRuntime } from '../provider';
-import type { CollectionItem } from '../runtime';
-
-interface UseCollectionResult {
-  /** Items in the collection (from the bound database). */
-  items: CollectionItem[];
-  loading: boolean;
-  error: Error | null;
-}
-
-/**
- * List collection items for the current route. Only meaningful on routes
- * that have a `collection` binding in `notis.config.ts`.
- *
- * ```tsx
- * const { items, loading } = useCollectionItems();
- * ```
- */
-export function useCollectionItems(): UseCollectionResult {
-  const runtime = useNotisRuntime();
-  const [items, setItems] = useState<CollectionItem[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  useEffect(() => {
-    if (!runtime) {
-      setLoading(false);
-      return;
-    }
-
-    let cancelled = false;
-    setLoading(true);
-
-    runtime
-      .listCollectionItems()
-      .then((result) => {
-        if (!cancelled) {
-          setItems(result.items);
-          setLoading(false);
-        }
-      })
-      .catch((err) => {
-        if (!cancelled) {
-          setError(err instanceof Error ? err : new Error(String(err)));
-          setLoading(false);
-        }
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [runtime]);
-
-  return { items, loading, error };
-}

package/template/packages/notis-sdk/src/hooks/useDocument.ts

@@ -1,61 +0,0 @@
-'use client';
-
-import { useCallback, useEffect, useState } from 'react';
-import { useNotisRuntime } from '../provider';
-import type { DocumentRecord } from '../runtime';
-
-interface UseDocumentResult {
-  document: DocumentRecord | null;
-  loading: boolean;
-  error: Error | null;
-  refetch: () => void;
-}
-
-/**
- * Fetch a single document by ID.
- *
- * ```tsx
- * const { document, loading } = useDocument(documentId);
- * ```
- */
-export function useDocument(documentId: string | null | undefined): UseDocumentResult {
-  const runtime = useNotisRuntime();
-  const [document, setDocument] = useState<DocumentRecord | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-  const [fetchKey, setFetchKey] = useState(0);
-
-  const refetch = useCallback(() => setFetchKey((k) => k + 1), []);
-
-  useEffect(() => {
-    if (!runtime || !documentId) {
-      setLoading(false);
-      return;
-    }
-
-    let cancelled = false;
-    setLoading(true);
-    setError(null);
-
-    runtime
-      .getDocument({ documentId })
-      .then((result) => {
-        if (!cancelled) {
-          setDocument(result);
-          setLoading(false);
-        }
-      })
-      .catch((err) => {
-        if (!cancelled) {
-          setError(err instanceof Error ? err : new Error(String(err)));
-          setLoading(false);
-        }
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [runtime, documentId, fetchKey]);
-
-  return { document, loading, error, refetch };
-}