@notis_ai/cli 0.2.0-beta.16.1 → 0.2.0-beta.160.1

package/template/packages/sdk/src/tailwind.ts

@@ -0,0 +1,56 @@
+/** Build-only SDK content discovery. Author configuration and PostCSS plugins stay intact. */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function notisTailwindContent() {
+  let root = process.cwd();
+  let temporary: string | undefined;
+  const wrappers = new Map<string, string>();
+  const cleanup = () => {
+    if (temporary) rmSync(temporary, { recursive: true, force: true });
+    temporary = undefined;
+    wrappers.clear();
+  };
+  return {
+    name: 'notis-sdk-tailwind-content',
+    enforce: 'pre' as const,
+    configResolved(config: { root: string }) { root = config.root; },
+    transform(source: string, id: string) {
+      if (!id.split('?')[0].endsWith('.css') || !/@tailwind\s/.test(source)) return null;
+      const explicit = source.match(/@config\s+(['"])(.*?)\1\s*;/);
+      const config = explicit
+        ? resolve(dirname(id.split('?')[0]), explicit[2])
+        : ['ts', 'js', 'cjs', 'mjs'].map(ext => join(root, `tailwind.config.${ext}`)).find(existsSync);
+      if (!config) return null;
+      let wrapper = wrappers.get(config);
+      if (!wrapper) {
+        temporary ||= mkdtempSync(join(tmpdir(), 'notis-tailwind-'));
+        wrapper = join(temporary, `config-${wrappers.size}.ts`);
+        const sdkGlob = join(dirname(fileURLToPath(import.meta.url)), '**/*.{ts,tsx}').replaceAll('\\', '/');
+        writeFileSync(wrapper, `import config from ${JSON.stringify(config)};
+import { resolve } from 'node:path';
+const content = config.content || [];
+const files = Array.isArray(content) ? content : (content.files || []);
+const base = ${JSON.stringify(root)};
+const relativeBase = ${JSON.stringify(dirname(config))};
+export default { ...config, content: {
+  ...(Array.isArray(content) ? {} : content),
+  relative: false,
+  files: [...files.map(file => typeof file !== 'string' ? file :
+    (file.startsWith('!') ? '!' : '') + resolve(content.relative ? relativeBase : base, file.replace(/^!/, ''))),
+    ${JSON.stringify(sdkGlob)}],
+} };
+`);
+        wrappers.set(config, wrapper);
+      }
+      const directive = `@config ${JSON.stringify('./' + relative(dirname(id.split('?')[0]), wrapper).replaceAll('\\', '/'))};`;
+      // Imports must remain before @config. Vite resolves them before PostCSS.
+      const code = explicit ? source.replace(explicit[0], directive) : `${source}\n${directive}\n`;
+      return { code, map: null };
+    },
+    closeBundle: cleanup,
+    closeWatcher: cleanup,
+  };
+}

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

@@ -14,10 +14,12 @@
  */
 
 import type { NotisAppConfig } from './config';
+import { notisTailwindContent } from './tailwind';
 
 export function notisViteConfig(appConfig: NotisAppConfig) {
   return {
     plugins: [
+      notisTailwindContent(),
       // @vitejs/plugin-react is added by the consumer's vite.config.ts
       // or auto-detected. We provide the config shape only.
     ],
@@ -28,14 +30,16 @@ export function notisViteConfig(appConfig: NotisAppConfig) {
         fileName: () => 'app.js',
       },
       rollupOptions: {
-        external: ['react', 'react-dom', 'react/jsx-runtime'],
+        external: ['react', 'react-dom', 'react-dom/client', 'react/jsx-runtime', 'react/jsx-dev-runtime'],
         output: {
           globals: {
             react: 'window.React',
             'react-dom': 'window.ReactDOM',
+            'react-dom/client': 'window.ReactDOMClient',
             'react/jsx-runtime': 'window.React',
           },
           assetFileNames: 'app[extname]',
+          inlineDynamicImports: true,
         },
       },
       outDir: '.notis/output/bundle',

package/template/tailwind.config.ts

@@ -7,6 +7,7 @@ const config: Config = {
     './app/**/*.{ts,tsx}',
     './components/**/*.{ts,tsx}',
     './lib/**/*.{ts,tsx}',
+    './packages/sdk/src/**/*.{ts,tsx}',
   ],
   theme: {
     extend: {

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/src/runtime/app-preview-server.js

@@ -1,312 +0,0 @@
-/**
- * Local preview server for built Notis app bundles.
- *
- * Serves a single index.html that loads the app bundle via <script type="module">.
- * Injects mock window.__NOTIS_RUNTIME__ before the bundle loads. Route switching
- * uses pathname navigation between route pages.
- *
- * Usage: `notis apps preview [dir]` starts this server on localhost:8787.
- */
-
-import { createServer } from 'node:http';
-import { existsSync, readFileSync } from 'node:fs';
-import { extname, resolve, sep } from 'node:path';
-
-import { readManifest } from './app-platform.js';
-
-// ---------------------------------------------------------------------------
-// Static file serving
-// ---------------------------------------------------------------------------
-
-function contentTypeFor(path) {
-  const types = {
-    '.html': 'text/html; charset=utf-8',
-    '.css': 'text/css; charset=utf-8',
-    '.js': 'text/javascript; charset=utf-8',
-    '.json': 'application/json; charset=utf-8',
-    '.svg': 'image/svg+xml',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.ico': 'image/x-icon',
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-  };
-  return types[extname(path)] || 'application/octet-stream';
-}
-
-// ---------------------------------------------------------------------------
-// Mock runtime generation
-// ---------------------------------------------------------------------------
-
-function buildSeedDocuments(databases) {
-  const state = {};
-  for (const slug of databases) {
-    state[slug] = Array.from({ length: 3 }, (_, i) => {
-      return {
-        id: `${slug}-seed-${i + 1}`,
-        databaseSlug: slug,
-        title: `${slug} ${i + 1}`,
-        properties: {},
-        icon: null,
-      };
-    });
-  }
-  return state;
-}
-
-function escapeHtml(value) {
-  return String(value)
-    .replaceAll('&', '&amp;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&#39;');
-}
-
-function sanitizeBundlePath(value, fallback) {
-  if (typeof value !== 'string') return fallback;
-  const normalized = value.trim().replaceAll('\\', '/').replace(/^\/+/, '');
-  if (!normalized || normalized.includes('..')) return fallback;
-  return /^[A-Za-z0-9._/-]+$/.test(normalized) ? normalized : fallback;
-}
-
-function serializeForInlineScript(value) {
-  return JSON.stringify(value).replaceAll('</', '<\\/').replaceAll('<!--', '<\\!--');
-}
-
-function buildPreviewHtml({ manifest, route, databases }) {
-  const app = manifest.app;
-  const seedState = buildSeedDocuments(databases);
-  const bundleJs = sanitizeBundlePath(manifest.bundle?.js, 'bundle/app.js');
-  const bundleCss = sanitizeBundlePath(manifest.bundle?.css, 'bundle/app.css');
-  const exportName = typeof route.export_name === 'string' && route.export_name ? route.export_name : 'index';
-  const pageTitle = escapeHtml(`${app.name} - ${route.name}`);
-  const bundleCssHref = escapeHtml(`/${bundleCss}`);
-  const bundleJsPathLiteral = JSON.stringify(`/${bundleJs}`);
-  const exportNameLiteral = JSON.stringify(exportName);
-
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>${pageTitle}</title>
-  <link rel="stylesheet" href="${bundleCssHref}" />
-  <script>
-(function() {
-  var DB = ${serializeForInlineScript(databases.map(function(slug) {
-    return { slug: slug, title: slug, properties: [] };
-  }))};
-  var STATE = ${serializeForInlineScript(seedState)};
-  var COLLECTION = ${serializeForInlineScript(route.collection || null)};
-
-  function titleProp(slug) {
-    var db = DB.find(function(d) { return d.slug === slug; });
-    return db && db.properties ? (db.properties.find(function(p) { return p.type === 'title'; }) || {}).name || 'title' : 'title';
-  }
-
-  function dbSlug(v) { return v || (COLLECTION && COLLECTION.database) || null; }
-
-  window.__NOTIS_RUNTIME__ = {
-    app: ${serializeForInlineScript(app)},
-    route: ${serializeForInlineScript(route)},
-    databases: DB,
-
-    navigate: function(payload) {
-      console.log('[notis-preview] Navigate:', payload);
-      if (payload.kind === 'route' && payload.path) {
-        window.location.assign(payload.path);
-      }
-    },
-
-    listTools: function() {
-      return Promise.resolve(${serializeForInlineScript((manifest.tools || []).map((name) => ({ name })))});
-    },
-
-    callTool: function(name, args) {
-      console.log('[notis-preview] Tool call:', name, args);
-      return Promise.reject(new Error('Tool calls are not available in local preview. Deploy the app to use real tools.'));
-    },
-
-    queryDatabase: function(args) {
-      var slug = dbSlug(args && args.databaseSlug);
-      var docs = (STATE[slug] || []).slice(args && args.offset || 0);
-      return Promise.resolve({ documents: docs });
-    },
-
-    getDocument: function(args) {
-      var id = args && args.documentId;
-      for (var slug in STATE) {
-        var match = STATE[slug].find(function(d) { return d.id === id; });
-        if (match) return Promise.resolve(match);
-      }
-      return Promise.reject(new Error('Document not found in preview.'));
-    },
-
-    upsertDocument: function(args) {
-      var slug = dbSlug(args && args.databaseSlug);
-      if (!slug) return Promise.reject(new Error('No database for upsert.'));
-      var docs = STATE[slug] || [];
-      var tp = titleProp(slug);
-      var existing = docs.find(function(d) { return d.id === (args && args.documentId); });
-      var props = Object.assign({}, existing && existing.properties, args && args.properties);
-      if (args && args.title) props[tp] = args.title;
-      var doc = {
-        id: existing ? existing.id : slug + '-' + Date.now(),
-        databaseSlug: slug,
-        title: props[tp] || 'Untitled',
-        properties: props,
-        icon: null
-      };
-      if (existing) {
-        var idx = docs.indexOf(existing);
-        docs[idx] = doc;
-      } else {
-        docs.unshift(doc);
-      }
-      STATE[slug] = docs;
-      return Promise.resolve({ status: 'success', document: doc });
-    },
-
-    listCollectionItems: function(args) {
-      var slug = dbSlug(args && args.databaseSlug);
-      if (!slug) return Promise.resolve({ items: [] });
-      var tp = (args && args.titleProperty) || titleProp(slug);
-      var docs = (STATE[slug] || []).slice(0, (args && args.pageSize) || 100);
-      return Promise.resolve({
-        items: docs.map(function(d) {
-          return { id: d.id, title: (d.properties && d.properties[tp]) || d.title || 'Untitled', icon: d.icon };
-        })
-      });
-    },
-
-    request: function() {
-      return Promise.reject(new Error('Backend requests are not available in local preview.'));
-    }
-  };
-})();
-  </script>
-</head>
-<body class="min-h-screen bg-background text-foreground antialiased">
-  <div id="notis-app-root"></div>
-  <script type="importmap">
-    {
-      "imports": {
-        "react": "https://esm.sh/react@19",
-        "react-dom": "https://esm.sh/react-dom@19?external=react",
-        "react-dom/client": "https://esm.sh/react-dom@19/client?external=react",
-        "react/jsx-runtime": "https://esm.sh/react@19/jsx-runtime"
-      }
-    }
-  </script>
-  <script type="module">
-    import React from 'react';
-    import { createRoot } from 'react-dom/client';
-    import * as AppBundle from ${bundleJsPathLiteral};
-
-    // Try to render: AppShell wrapping the route component, or just the route component
-    const exportName = ${exportNameLiteral};
-    const RouteComponent = AppBundle[exportName] || AppBundle['default'];
-    const AppShell = AppBundle['__AppShell'];
-
-    if (RouteComponent) {
-      const root = document.getElementById('notis-app-root');
-      if (root) {
-        const reactRoot = createRoot(root);
-        if (AppShell) {
-          reactRoot.render(React.createElement(AppShell, null, React.createElement(RouteComponent)));
-        } else {
-          reactRoot.render(React.createElement(RouteComponent));
-        }
-      }
-    } else {
-      document.getElementById('notis-app-root').innerHTML =
-        '<p style="padding:2rem;color:red;">No component found for export "' + exportName + '". Available exports: ' +
-        Object.keys(AppBundle).join(', ') + '</p>';
-    }
-  </script>
-</body>
-</html>`;
-}
-
-// ---------------------------------------------------------------------------
-// Server
-// ---------------------------------------------------------------------------
-
-function normalizePathname(pathname) {
-  if (!pathname || pathname === '/') return '/';
-  return pathname.endsWith('/') ? pathname.slice(0, -1) || '/' : pathname;
-}
-
-function resolveSafePath(baseDir, pathname) {
-  const normalizedBaseDir = resolve(baseDir);
-  const resolvedPath = resolve(normalizedBaseDir, pathname.replace(/^\/+/, ''));
-  if (resolvedPath === normalizedBaseDir || resolvedPath.startsWith(`${normalizedBaseDir}${sep}`)) {
-    return resolvedPath;
-  }
-  return null;
-}
-
-export async function startPreviewServer({ projectDir, port }) {
-  const manifest = readManifest(projectDir);
-  const outputDir = resolve(projectDir, '.notis/output');
-  const bundleDir = resolve(projectDir, '.notis/output/bundle');
-  const databases = (manifest.databases || []).filter((slug) => typeof slug === 'string' && slug);
-  const routesByPath = new Map((manifest.routes || []).map((r) => [normalizePathname(r.path), r]));
-  const defaultRoute = (manifest.routes || []).find((r) => r.default) || manifest.routes?.[0];
-
-  if (!defaultRoute) {
-    throw new Error('Manifest contains no routes.');
-  }
-
-  const server = createServer((request, response) => {
-    const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
-    const pathname = normalizePathname(url.pathname);
-
-    // Serve bundle files directly
-    if (pathname.startsWith('/bundle/')) {
-      const filePath = resolveSafePath(outputDir, pathname);
-      if (filePath && existsSync(filePath)) {
-        response.writeHead(200, { 'Content-Type': contentTypeFor(filePath), 'Cache-Control': 'no-store' });
-        response.end(readFileSync(filePath));
-        return;
-      }
-    }
-
-    // Redirect / to default route if it's not /
-    if (pathname === '/' && defaultRoute.path !== '/') {
-      response.writeHead(302, { Location: defaultRoute.path });
-      response.end();
-      return;
-    }
-
-    // Serve route HTML with runtime injection
-    const route = routesByPath.get(pathname) || (pathname === '/' ? defaultRoute : null);
-    if (route) {
-      const html = buildPreviewHtml({ manifest, route, databases });
-      response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' });
-      response.end(html);
-      return;
-    }
-
-    // Serve static files from bundle dir
-    const filePath = resolveSafePath(bundleDir, pathname);
-    if (filePath && existsSync(filePath)) {
-      response.writeHead(200, { 'Content-Type': contentTypeFor(filePath), 'Cache-Control': 'no-store' });
-      response.end(readFileSync(filePath));
-      return;
-    }
-
-    response.writeHead(404, { 'Content-Type': 'text/plain' });
-    response.end('Not found');
-  });
-
-  await new Promise((resolveP, rejectP) => {
-    server.on('error', rejectP);
-    server.listen(port, '127.0.0.1', resolveP);
-  });
-
-  // Keep running until interrupted
-  await new Promise(() => {});
-}

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

@@ -1,48 +0,0 @@
-/**
- * Configuration utilities for notis.config.ts.
- *
- * Usage:
- * ```ts
- * // notis.config.ts
- * import { defineNotisApp } from '@notis/sdk/config';
- *
- * export default defineNotisApp({
- *   name: 'My App',
- *   description: 'Does things',
- *   icon: 'lucide:layout-dashboard',
- *   databases: ['tasks'],
- *   routes: [...],
- *   tools: [...],
- * });
- * ```
- */
-
-export interface NotisRouteConfig {
-  path: string;
-  name: string;
-  icon?: string;
-  default?: boolean;
-  exportName?: string;
-  collection?: {
-    database: string;
-    titleProperty: string;
-  };
-}
-
-export interface NotisAppConfig {
-  name: string;
-  description?: string;
-  icon?: string;
-  databases?: string[];
-  routes?: NotisRouteConfig[];
-  tools?: string[];
-}
-
-/**
- * Identity function that provides type checking and autocomplete for the
- * Notis app configuration. The returned object is read at build time by
- * `notis apps build` to generate the manifest.
- */
-export function defineNotisApp(config: NotisAppConfig): NotisAppConfig {
-  return config;
-}