@notis_ai/cli 0.2.0-beta.191.1 → 0.2.0-beta.197.1

package/dist/base-skills/notis-query/references/query.md

@@ -1,543 +1,76 @@
-## Supported execution mode
+# Structured native query grammar
 
-`LOCAL_NOTIS_DATABASE_QUERY` supports direct structured queries only.
-
-Natural-language query generation is retired. Do not send free-form requests like "find overdue tasks from important clients"; build the structured `query` payload yourself.
-
-## Request shape
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "database_slug": "tasks",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Status",
-          "type": "status",
-          "operator": "equals",
-          "value": "In Progress"
-        }
-      ]
-    },
-    "sorts": [
-      {
-        "property": "Due Date",
-        "direction": "ascending"
-      }
-    ],
-    "page_size": 20
-  },
-  "offset": 0
-}
-```
-
-Top-level fields:
-
-- One of `database_id` or `database_slug` is required.
-- `database_id`: stable native database ID. Prefer this when it is available from database context, `list_databases`, or `get_database`.
-- `database_slug`: native database slug. Use this when `database_id` is not available, or pass it alongside `database_id` as a fallback.
-- `query`: required object
-- `offset`: optional numeric pagination offset
-
-When both `database_id` and `database_slug` are provided, they must identify the same database. If the ID is stale and no database is found by ID, the runtime may fall back to the slug.
-
-`query` fields:
-
-- `filter`: optional rule tree
-- `sorts`: optional array of sort definitions
-- `page_size`: optional integer page size
-
-## Filter shape
-
-```json
-{
-  "operator": "and",
-  "conditions": [
-    {
-      "property": "Status",
-      "type": "status",
-      "operator": "equals",
-      "value": "In Progress"
-    },
-    {
-      "property": "Priority",
-      "type": "select",
-      "operator": "equals",
-      "value": "High"
-    }
-  ]
-}
-```
-
-Use nested groups when needed:
-
-```json
-{
-  "operator": "or",
-  "conditions": [
-    {
-      "property": "Status",
-      "type": "status",
-      "operator": "equals",
-      "value": "Todo"
-    },
-    {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Priority",
-          "type": "select",
-          "operator": "equals",
-          "value": "High"
-        },
-        {
-          "property": "Archived",
-          "type": "checkbox",
-          "operator": "equals",
-          "value": false
-        }
-      ]
-    }
-  ]
-}
-```
-
-## Supported property semantics
-
-Use the real Notis property name and the correct property type.
-
-### Title and rich text
-
-Recommended operators:
-
-- `contains`
-- `equals`
-- `not_equals`
-
-Example:
-
-```json
-{
-  "property": "Title",
-  "type": "title",
-  "operator": "contains",
-  "value": "launch"
-}
-```
-
-### Select and status
-
-Recommended operators:
-
-- `equals`
-- `not_equals`
-- `in`
-
-Example:
-
-```json
-{
-  "property": "Status",
-  "type": "status",
-  "operator": "equals",
-  "value": "Done"
-}
-```
-
-### Multi-select
-
-Recommended operators:
-
-- `contains`
-- `not_contains`
-
-Example:
-
-```json
-{
-  "property": "Tags",
-  "type": "multi_select",
-  "operator": "contains",
-  "value": "Urgent"
-}
-```
-
-### Checkbox
-
-Recommended operator:
-
-- `equals`
-
-Example:
-
-```json
-{
-  "property": "Archived",
-  "type": "checkbox",
-  "operator": "equals",
-  "value": false
-}
-```
-
-### Number
-
-Recommended operators:
-
-- `equals`
-- `not_equals`
-- `greater_than`
-- `greater_than_or_equal`
-- `less_than`
-- `less_than_or_equal`
-
-Example:
-
-```json
-{
-  "property": "Score",
-  "type": "number",
-  "operator": "greater_than_or_equal",
-  "value": 80
-}
-```
-
-### Date
-
-Recommended operators:
-
-- `equals`
-- `before`
-- `after`
-- `on_or_before`
-- `on_or_after`
-
-Use ISO dates or timestamps depending on the property precision.
-
-Example:
+Discover and inspect `LOCAL_NOTIS_DATABASE_QUERY`; use its current input schema.
+For native Spaces use `protocol: 1`, the exact discovery `target`, and `input`.
+The native query lives directly inside `input`, without another request/query wrapper.
 
 ```json
 {
-  "property": "Due Date",
-  "type": "date",
-  "operator": "on_or_before",
-  "value": "2026-03-31"
-}
-```
-
-### Relation
-
-Recommended operators:
-
-- `contains`
-- `not_contains`
-
-Pass the related `document_id`, not the display title.
-
-Example:
-
-```json
-{
-  "property": "Project",
-  "type": "relation",
-  "operator": "contains",
-  "value": "doc_project_123"
-}
-```
-
-### Formula
-
-Treat formula values according to the returned data type. In practice, use the matching operator family for the computed result:
-
-- text-like formula: `contains` or `equals`
-- number-like formula: numeric comparison operators
-- boolean-like formula: `equals`
-
-Only use formula filters when the formula property already exists in the schema.
-
-## Sorts
-
-Sort objects look like this:
-
-```json
-{
-  "property": "Created At",
-  "direction": "descending"
-}
-```
-
-Recommended directions:
-
-- `ascending`
-- `descending`
-
-Common sorts:
-
-- title sorts for alphabetical browsing
-- status then date sorts for workflow queues
-- timestamp sorts such as `Created At`, `Updated At`, or `Last Edited Time`
-
-Example:
-
-```json
-[
-  {
-    "property": "Last Edited Time",
-    "direction": "descending"
+  "protocol": 1,
+  "target": {"space_id": "<exact-discovered-space-id>", "binding": "<exact-discovered-binding-id>"},
+  "input": {
+    "mode": "rows",
+    "filter": {"field": {"property": "Status"}, "op": "equals", "value": "Done"},
+    "sorts": [{"field": {"column": "updated_at"}, "direction": "desc"}],
+    "page_size": 20,
+    "offset": 0,
+    "include_content": false
   }
-]
-```
-
-## Pagination
-
-Use `page_size` to cap the number of results per call.
-
-The response returns:
-
-- `documents`
-- `results_count`
-- `has_more`
-- `next_offset`
-- `query`
-- `complementary_instructions`
-
-Pagination rules:
-
-- start with `offset: 0` or omit it
-- if `has_more` is true, call again with `offset: next_offset`
-
-Example follow-up call:
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "page_size": 25
-  },
-  "offset": 25
 }
 ```
 
-## Response shape
+Use the complete Space binding target returned by schema discovery. Every
+database lives in a Space: a bare `database_id` gets `resolved_target` from
+`LOCAL_NOTIS_DATABASE_GET_DATABASE`, and a bare-id query answers
+`database_in_spaces` with its links. Never remove its record context or substitute
+another database/owner after a denial. `action_id`, when present, retains the
+saved action's narrower authority rather than granting direct Editor access.
 
-The result includes database rows in `documents`. Each document usually contains:
+## Fields and filters
 
-- `document_id`
-- title-like display fields
-- matching property values
-- metadata helpful for follow-up reads or updates
+Choose one field reference: `{property_id}`, an unambiguous `{property}` label,
+or a supported `{column}` such as `record_key`, `id`, `title`, `created_at`,
+`updated_at`, `last_edited_time`, `content_type`, `file_type`. Current property
+names take precedence; use stable IDs when names are ambiguous.
 
-Use `document_id` from the query response when you need to:
+A condition is `{field, op, value}`. Empty checks (`is_empty`, `is_not_empty`)
+omit `value`. Combine with `{and: [conditions]}` or `{or: [conditions]}`; groups
+must be nonempty. Invalid conditions fail—they never become an unrestricted query.
 
-- fetch full content with `LOCAL_NOTIS_DATABASE_GET_DOCUMENT`
-- update a record with a generated database upsert tool
-- attach it to a relation field in another upsert
+| Type | Operators |
+| --- | --- |
+| Record identity | `equals`, `not_equals`, `in` |
+| Text/title/URL | `equals`, `not_equals`, `contains`, `not_contains`, `starts_with`, `ends_with`, empty checks |
+| Number | `equals`, `not_equals`, `greater_than`, `less_than`, inclusive variants, empty checks |
+| Checkbox | `equals`, `not_equals` with real booleans |
+| Select/status | `equals`, `not_equals`, empty checks; use a current option ID or unambiguous label |
+| Multi-select/relation | `contains`, `does_not_contain`, empty checks |
+| Date | `equals`, `before`, `after`, `on_or_before`, `on_or_after`, empty checks; use ISO dates/timestamps |
 
-## Examples
+A relation filter uses the related record identity returned by its native read,
+not a guessed title. Do not encode a relation as a scalar text equality. Avoid
+assuming every application uses the same status labels or Inbox semantics.
 
-### Title or rich text contains
+## Pagination and projection
 
-```json
-{
-  "database_id": "notes-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Title",
-          "type": "title",
-          "operator": "contains",
-          "value": "pricing"
-        }
-      ]
-    },
-    "page_size": 10
-  }
-}
-```
+Use bounded pages (1–500) and the returned continuation/offset until complete.
+Native row results expose `rows`, stable `record_key`, revision and schema
+metadata; do not assume the older `documents` result shape. Sorts use
+`{field, direction: 'asc'|'desc'}`. Multi-select/relation fields cannot be sorted.
 
-### Select or status equals
+Use `include_content: false` for lists. Include bodies only when needed.
+Archived rows are excluded unless `include_archived: true`; binned/inaccessible
+rows remain excluded by authority. Do not turn a missing page into a zero count.
 
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Status",
-          "type": "status",
-          "operator": "equals",
-          "value": "In Progress"
-        }
-      ]
-    }
-  }
-}
-```
-
-### Multi-select contains
-
-```json
-{
-  "database_id": "content-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Tags",
-          "type": "multi_select",
-          "operator": "contains",
-          "value": "Newsletter"
-        }
-      ]
-    }
-  }
-}
-```
-
-### Checkbox equals
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Completed",
-          "type": "checkbox",
-          "operator": "equals",
-          "value": true
-        }
-      ]
-    }
-  }
-}
-```
-
-### Number comparison
-
-```json
-{
-  "database_id": "deals-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Amount",
-          "type": "number",
-          "operator": "greater_than",
-          "value": 10000
-        }
-      ]
-    }
-  }
-}
-```
-
-### Date comparison
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Due Date",
-          "type": "date",
-          "operator": "on_or_after",
-          "value": "2026-03-01"
-        }
-      ]
-    },
-    "sorts": [
-      {
-        "property": "Due Date",
-        "direction": "ascending"
-      }
-    ]
-  }
-}
-```
-
-### Relation contains
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "filter": {
-      "operator": "and",
-      "conditions": [
-        {
-          "property": "Project",
-          "type": "relation",
-          "operator": "contains",
-          "value": "doc_project_123"
-        }
-      ]
-    }
-  }
-}
-```
-
-### Timestamp sort
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "sorts": [
-      {
-        "property": "Last Edited Time",
-        "direction": "descending"
-      }
-    ],
-    "page_size": 20
-  }
-}
-```
-
-### Pagination follow-up
-
-First call:
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "page_size": 20
-  }
-}
-```
-
-Second call after a response with `has_more: true` and `next_offset: 20`:
-
-```json
-{
-  "database_id": "tasks-db-id",
-  "query": {
-    "page_size": 20
-  },
-  "offset": 20
-}
-```
+## Count, aggregate and search
 
-## Practical workflow
+- `mode: 'count'` applies the same authorized filter and returns its count.
+- `mode: 'aggregate'` adds `aggregate: {op: 'sum'|'avg'|'min'|'max', field}` over
+  a numeric field. It is computed within the same native scope.
+- `mode: 'search'` adds `search: {text, fields: [field, ...]}` over supported text
+  fields; this is structured native search, not semantic memory retrieval.
+- For one current body, use `input: {mode: 'document_body', record_key}` with the
+  exact body-capable target. The response includes Markdown and current revisions.
 
-1. Call `LOCAL_NOTIS_DATABASE_LIST_DATABASES` if you do not know the database ID yet.
-2. Call `LOCAL_NOTIS_DATABASE_GET_DATABASE` if you need schema detail before building filters or relation payloads.
-3. Call `LOCAL_NOTIS_DATABASE_QUERY` with `database_id` plus structured filters and sorts. Use `database_slug` only when the ID is not available.
-4. If you need the full body of one row, call `LOCAL_NOTIS_DATABASE_GET_DOCUMENT` with the returned `document_id`.
-5. If you need to update one of the matched rows, call the relevant generated database upsert tool with that `document_id`.
-6. If you need a relation value, query the related database first and pass the resulting `document_id` into the upsert.
+For visual dashboards or a link's selected params, resolve/render the view rather
+than guessing that an independent query recreates its presentation or period.

package/dist/sdk/src/bundleModule.ts

@@ -0,0 +1,79 @@
+/** Framework-neutral ESM loading shared by Portal and credentialless verification. */
+import type React from 'react';
+
+export function rewriteReactImports(source: string): string {
+  // Create inline data URLs that re-export from window globals.
+  // This avoids the "Cannot find module" error with blob URL imports.
+  const reactShim = `data:text/javascript,${encodeURIComponent(
+    'const R = window.React; export default R; export const { createContext, createRef, useState, useEffect, useContext, useCallback, useMemo, useRef, useReducer, useLayoutEffect, useId, memo, forwardRef, createElement, Fragment, Children, cloneElement, isValidElement, lazy, Suspense, startTransition, useTransition, useDeferredValue, useSyncExternalStore, useInsertionEffect, useDebugValue, useImperativeHandle, Component, PureComponent } = R;'
+  )}`;
+  const jsxShim = `data:text/javascript,${encodeURIComponent(
+    'const J = window.__ReactJSXRuntime || {}; const R = window.React; export const jsx = J.jsx || R.createElement; export const jsxs = J.jsxs || R.createElement; export const jsxDEV = J.jsxDEV || R.createElement; export const Fragment = J.Fragment || R.Fragment;'
+  )}`;
+  const reactDomShim = `data:text/javascript,${encodeURIComponent(
+    'const RD = window.ReactDOM; export default RD; export const { createPortal, flushSync, unstable_batchedUpdates } = RD;'
+  )}`;
+  const reactDomClientShim = `data:text/javascript,${encodeURIComponent(
+    'const RDC = window.ReactDOMClient; export default RDC; export const { createRoot, hydrateRoot } = RDC;'
+  )}`;
+
+  let result = source;
+  // Replace bare side-effect imports
+  result = result.replace(/import\s*["']react-dom\/client["'];?/g, `import "${reactDomClientShim}";`);
+  result = result.replace(/import\s*["']react-dom["'];?/g, `import "${reactDomShim}";`);
+  result = result.replace(/import\s*["']react\/jsx-runtime["'];?/g, `import "${jsxShim}";`);
+  result = result.replace(/import\s*["']react\/jsx-dev-runtime["'];?/g, `import "${jsxShim}";`);
+  result = result.replace(/import\s*["']react["'];?/g, `import "${reactShim}";`);
+
+  // Replace import statements with data URL shims
+  // Handle: import { ... } from "react/jsx-runtime"
+  result = result.replace(/from\s*["']react\/jsx-runtime["']/g, `from "${jsxShim}"`);
+  result = result.replace(/from\s*["']react\/jsx-dev-runtime["']/g, `from "${jsxShim}"`);
+  // Handle react-dom/client before react-dom
+  result = result.replace(/from\s*["']react-dom\/client["']/g, `from "${reactDomClientShim}"`);
+  // Handle: import ... from "react-dom"
+  result = result.replace(/from\s*["']react-dom["']/g, `from "${reactDomShim}"`);
+  // Handle: import ... from "react" (must come after react-dom and react/jsx-runtime)
+  result = result.replace(/from\s*["']react["']/g, `from "${reactShim}"`);
+
+  return result;
+}
+
+export function resolveBundleRouteExport(
+  moduleExports: Record<string, React.ComponentType>,
+  exportCandidates: string[],
+  strict = false,
+): { name: string; component: React.ComponentType } | null {
+  const namedExport = exportCandidates.find((name) => Boolean(moduleExports[name]));
+  if (namedExport) {
+    return { name: namedExport, component: moduleExports[namedExport] };
+  }
+  if (strict) return null;
+  if (moduleExports.default) {
+    return { name: 'default', component: moduleExports.default };
+  }
+
+  // Vite may minify an entry export even though the manifest still carries
+  // its source name. A bundle with one non-shell component is unambiguous, so
+  // keep Dev usable instead of showing "View not available" for that route.
+  const componentExports = Object.entries(moduleExports).filter(
+    ([name, value]) => name !== '__AppShell' && Boolean(value),
+  );
+  if (componentExports.length !== 1) {
+    return null;
+  }
+  const [name, component] = componentExports[0];
+  return { name, component };
+}
+
+export async function importRewrittenBundleSource(source: string): Promise<Record<string, React.ComponentType>> {
+  const blob = new Blob([source], { type: 'text/javascript' });
+  const url = URL.createObjectURL(blob);
+  try {
+    return await import(/* webpackIgnore: true */ url) as Record<string, React.ComponentType>;
+  } finally { URL.revokeObjectURL(url); }
+}
+
+export function importBundleSource(source: string) {
+  return importRewrittenBundleSource(rewriteReactImports(source));
+}