npm - @notis_ai/cli - Versions diffs - 0.2.0-beta.16.1 - Mend

@notis_ai/cli 0.2.0-beta.16.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/README.md +335 -0
package/bin/notis.js +2 -0
package/package.json +38 -0
package/src/cli.js +147 -0
package/src/command-specs/apps.js +496 -0
package/src/command-specs/auth.js +178 -0
package/src/command-specs/db.js +163 -0
package/src/command-specs/helpers.js +193 -0
package/src/command-specs/index.js +20 -0
package/src/command-specs/meta.js +154 -0
package/src/command-specs/tools.js +391 -0
package/src/runtime/app-platform.js +624 -0
package/src/runtime/app-preview-server.js +312 -0
package/src/runtime/errors.js +55 -0
package/src/runtime/help.js +60 -0
package/src/runtime/output.js +180 -0
package/src/runtime/profiles.js +202 -0
package/src/runtime/transport.js +198 -0
package/template/app/globals.css +3 -0
package/template/app/layout.tsx +7 -0
package/template/app/page.tsx +55 -0
package/template/components/ui/badge.tsx +28 -0
package/template/components/ui/button.tsx +53 -0
package/template/components/ui/card.tsx +56 -0
package/template/components.json +20 -0
package/template/lib/utils.ts +6 -0
package/template/notis.config.ts +18 -0
package/template/package.json +32 -0
package/template/packages/notis-sdk/package.json +26 -0
package/template/packages/notis-sdk/src/config.ts +48 -0
package/template/packages/notis-sdk/src/helpers.ts +131 -0
package/template/packages/notis-sdk/src/hooks/useAppState.ts +50 -0
package/template/packages/notis-sdk/src/hooks/useBackend.ts +41 -0
package/template/packages/notis-sdk/src/hooks/useCollectionItem.ts +58 -0
package/template/packages/notis-sdk/src/hooks/useDatabase.ts +87 -0
package/template/packages/notis-sdk/src/hooks/useDocument.ts +61 -0
package/template/packages/notis-sdk/src/hooks/useNotis.ts +31 -0
package/template/packages/notis-sdk/src/hooks/useNotisNavigation.ts +49 -0
package/template/packages/notis-sdk/src/hooks/useTool.ts +49 -0
package/template/packages/notis-sdk/src/hooks/useTools.ts +56 -0
package/template/packages/notis-sdk/src/hooks/useUpsertDocument.ts +57 -0
package/template/packages/notis-sdk/src/index.ts +47 -0
package/template/packages/notis-sdk/src/provider.tsx +44 -0
package/template/packages/notis-sdk/src/runtime.ts +159 -0
package/template/packages/notis-sdk/src/styles.css +123 -0
package/template/packages/notis-sdk/src/ui.ts +15 -0
package/template/packages/notis-sdk/src/vite.ts +54 -0
package/template/packages/notis-sdk/tsconfig.json +15 -0
package/template/postcss.config.mjs +8 -0
package/template/tailwind.config.ts +58 -0
package/template/tsconfig.json +22 -0
package/template/vite.config.ts +10 -0

package/src/runtime/app-preview-server.js ADDED Viewed

@@ -0,0 +1,312 @@
+/**
+ * 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/src/runtime/errors.js ADDED Viewed

@@ -0,0 +1,55 @@
+export const EXIT_CODES = {
+  ok: 0,
+  usage: 2,
+  auth: 3,
+  network: 4,
+  conflict: 5,
+  backend: 6,
+  unexpected: 7,
+};
+export class CliError extends Error {
+  constructor({
+    code,
+    message,
+    exitCode = EXIT_CODES.unexpected,
+    retryable = false,
+    details = {},
+    hints = [],
+    warnings = [],
+    cause,
+  }) {
+    super(message);
+    this.name = 'CliError';
+    this.code = code;
+    this.exitCode = exitCode;
+    this.retryable = retryable;
+    this.details = details;
+    this.hints = hints;
+    this.warnings = warnings;
+    this.cause = cause;
+  }
+}
+export function asCliError(error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  return new CliError({
+    code: 'unexpected_error',
+    message: error instanceof Error ? error.message : String(error),
+    exitCode: EXIT_CODES.unexpected,
+    cause: error,
+  });
+}
+export function usageError(message, details = {}) {
+  return new CliError({
+    code: 'usage_error',
+    message,
+    details,
+    exitCode: EXIT_CODES.usage,
+  });
+}

package/src/runtime/help.js ADDED Viewed

@@ -0,0 +1,60 @@
+import { usageError } from './errors.js';
+export function canonicalCommandName(spec) {
+  return spec.display_name || spec.command_path.join(' ');
+}
+export function formatDescribe(spec) {
+  const lines = [
+    `${canonicalCommandName(spec)}`,
+    '',
+    spec.summary,
+    '',
+    'When to use:',
+    `  ${spec.when_to_use}`,
+    '',
+    `Mutates state: ${spec.mutates ? 'yes' : 'no'}`,
+    `Idempotent: ${spec.idempotent ? 'yes' : 'no'}`,
+    '',
+    'Arguments and options:',
+  ];
+  const args = spec.args_schema?.arguments || [];
+  const options = spec.args_schema?.options || [];
+  if (!args.length && !options.length) {
+    lines.push('  None');
+  } else {
+    for (const arg of args) {
+      lines.push(`  ${arg.token}  ${arg.description}`);
+    }
+    for (const option of options) {
+      lines.push(`  ${option.flags}  ${option.description}`);
+    }
+  }
+  lines.push('', 'Examples:');
+  for (const example of spec.examples || []) {
+    lines.push(`  ${example}`);
+  }
+  lines.push('', 'Output shape:', `  ${spec.output_schema}`);
+  lines.push('', 'Backend call:', `  ${JSON.stringify(spec.backend_call)}`);
+  if (spec.related_commands?.length) {
+    lines.push('', 'Related commands:');
+    for (const related of spec.related_commands) {
+      lines.push(`  ${related}`);
+    }
+  }
+  return lines.join('\n');
+}
+export function findCommandSpec(specs, inputPath) {
+  const normalized = inputPath.join(' ').trim().toLowerCase();
+  const spec = specs.find((entry) => entry.command_path.join(' ').toLowerCase() === normalized);
+  if (!spec) {
+    throw usageError(`Unknown command path: ${inputPath.join(' ')}`);
+  }
+  return spec;
+}

package/src/runtime/output.js ADDED Viewed

@@ -0,0 +1,180 @@
+import { inspect } from 'node:util';
+import { EXIT_CODES } from './errors.js';
+function pad(value, width) {
+  return String(value).padEnd(width);
+}
+function formatTable(rows, columns) {
+  if (!rows.length) {
+    return '';
+  }
+  const widths = columns.map((column) => {
+    const headerWidth = column.label.length;
+    const valueWidth = Math.max(...rows.map((row) => String(column.value(row) ?? '').length), 0);
+    return Math.max(headerWidth, valueWidth);
+  });
+  const header = columns.map((column, index) => pad(column.label, widths[index])).join('  ');
+  const divider = columns.map((_, index) => '-'.repeat(widths[index])).join('  ');
+  const body = rows.map((row) => columns.map((column, index) => pad(column.value(row) ?? '', widths[index])).join('  '));
+  return [header, divider, ...body].join('\n');
+}
+function yamlScalar(value) {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return JSON.stringify(String(value));
+}
+function toYaml(value, indent = 0) {
+  const prefix = ' '.repeat(indent);
+  if (Array.isArray(value)) {
+    if (!value.length) {
+      return `${prefix}[]`;
+    }
+    return value
+      .map((item) => {
+        if (item && typeof item === 'object') {
+          const nested = toYaml(item, indent + 2);
+          return `${prefix}-\n${nested}`;
+        }
+        return `${prefix}- ${yamlScalar(item)}`;
+      })
+      .join('\n');
+  }
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value);
+    if (!entries.length) {
+      return `${prefix}{}`;
+    }
+    return entries
+      .map(([key, nestedValue]) => {
+        if (nestedValue && typeof nestedValue === 'object') {
+          return `${prefix}${key}:\n${toYaml(nestedValue, indent + 2)}`;
+        }
+        return `${prefix}${key}: ${yamlScalar(nestedValue)}`;
+      })
+      .join('\n');
+  }
+  return `${prefix}${yamlScalar(value)}`;
+}
+function serializeMachineEnvelope(envelope, outputMode) {
+  if (outputMode === 'yaml') {
+    return `${toYaml(envelope)}\n`;
+  }
+  if (outputMode === 'ndjson') {
+    return `${JSON.stringify(envelope)}\n`;
+  }
+  return `${JSON.stringify(envelope, null, 2)}\n`;
+}
+export class OutputManager {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  isMachineMode() {
+    return this.runtime.outputMode !== 'table';
+  }
+  writeWarning(message) {
+    if (this.isMachineMode()) {
+      return;
+    }
+    process.stderr.write(`${message}\n`);
+  }
+  emitSuccess({
+    command,
+    data = {},
+    humanSummary,
+    hints = [],
+    warnings = [],
+    requestId = null,
+    meta = {},
+    renderHuman,
+  }) {
+    const envelope = {
+      ok: true,
+      command,
+      data,
+      human_summary: humanSummary,
+      hints,
+      warnings,
+      request_id: requestId,
+      meta: {
+        profile: this.runtime.profileName,
+        api_base: this.runtime.apiBase,
+        mutating: Boolean(meta.mutating),
+        ...meta,
+      },
+    };
+    if (this.isMachineMode()) {
+      process.stdout.write(serializeMachineEnvelope(envelope, this.runtime.outputMode));
+      return EXIT_CODES.ok;
+    }
+    for (const warning of warnings) {
+      this.writeWarning(`Warning: ${warning}`);
+    }
+    if (typeof renderHuman === 'function') {
+      const rendered = renderHuman();
+      if (rendered) {
+        process.stdout.write(`${rendered}\n`);
+      }
+    } else if (humanSummary) {
+      process.stdout.write(`${humanSummary}\n`);
+    } else if (Object.keys(data).length) {
+      process.stdout.write(`${inspect(data, { depth: null, colors: this.runtime.color })}\n`);
+    }
+    if (hints.length) {
+      const lines = hints.map((hint) => `  ${hint.command}  ${hint.reason}`);
+      process.stdout.write(`\nNext:\n${lines.join('\n')}\n`);
+    }
+    return EXIT_CODES.ok;
+  }
+  emitError({ command, error, requestId = null }) {
+    const envelope = {
+      ok: false,
+      command,
+      error: {
+        code: error.code,
+        message: error.message,
+        retryable: Boolean(error.retryable),
+        details: error.details || {},
+      },
+      hints: error.hints || [],
+      warnings: error.warnings || [],
+      request_id: requestId,
+    };
+    if (this.isMachineMode()) {
+      process.stdout.write(serializeMachineEnvelope(envelope, this.runtime.outputMode));
+      return error.exitCode || EXIT_CODES.unexpected;
+    }
+    process.stderr.write(`Error: ${error.message}\n`);
+    for (const hint of error.hints || []) {
+      process.stderr.write(`  ${hint.command}  ${hint.reason}\n`);
+    }
+    return error.exitCode || EXIT_CODES.unexpected;
+  }
+}
+export { formatTable };