@notis_ai/cli 0.2.2 → 0.2.4

package/dist/scaffolds/notis-random/lib/notis-tools.ts

@@ -0,0 +1,109 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import { useTool } from '@notis/sdk';
+import type { RollDocument } from '@/lib/roll-record';
+import type { Roll } from '@/lib/rng';
+import { formatNumber } from '@/lib/utils';
+
+type QueryRollsArgs = {
+  database_slug: 'rolls';
+  query?: {
+    page_size?: number;
+  };
+  offset?: number;
+};
+
+type QueryRollsResult = {
+  documents?: RollDocument[];
+  message?: string;
+  error?: string;
+};
+
+type UpsertRollArgs = {
+  title: string;
+  Value: number;
+  Mode: Roll['mode'];
+  Min: number;
+  Max: number;
+  'Rolled At': string;
+};
+
+type UpsertRollResult = {
+  status?: string;
+  document?: RollDocument;
+  message?: string;
+  error?: string;
+};
+
+export function useRollDocuments(pageSize?: number) {
+  const queryRolls = useTool<QueryRollsArgs, QueryRollsResult>('LOCAL_NOTIS_DATABASE_QUERY');
+  const [documents, setDocuments] = useState<RollDocument[]>([]);
+  const [error, setError] = useState<Error | null>(null);
+  const [fetchKey, setFetchKey] = useState(0);
+
+  const refetch = useCallback(() => {
+    setFetchKey((key) => key + 1);
+  }, []);
+
+  useEffect(() => {
+    let cancelled = false;
+    setError(null);
+
+    queryRolls
+      .call({ database_slug: 'rolls', query: { page_size: pageSize } })
+      .then((result) => {
+        if (cancelled) return;
+        const message = result.error ?? result.message;
+        if (message && !result.documents) {
+          throw new Error(message);
+        }
+        setDocuments(result.documents ?? []);
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setDocuments([]);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [fetchKey, pageSize, queryRolls.call]);
+
+  return {
+    documents,
+    loading: queryRolls.loading,
+    error: queryRolls.error ?? error,
+    refetch,
+  };
+}
+
+export function usePersistRoll() {
+  const upsertRoll = useTool<UpsertRollArgs, UpsertRollResult>('LOCAL_NOTIS_DATABASE_UPSERT_ROLLS');
+
+  const persist = useCallback(
+    async (roll: Roll) => {
+      const result = await upsertRoll.call({
+        title: formatNumber(roll.value),
+        Value: roll.value,
+        Mode: roll.mode,
+        Min: roll.min,
+        Max: roll.max,
+        'Rolled At': roll.at,
+      });
+      const message = result.error ?? result.message;
+      if (message && result.status === 'error') {
+        throw new Error(message);
+      }
+      return result.document ?? null;
+    },
+    [upsertRoll.call],
+  );
+
+  return {
+    persist,
+    loading: upsertRoll.loading,
+    error: upsertRoll.error,
+  };
+}

package/dist/scaffolds/notis-random/lib/rng.ts

@@ -0,0 +1,42 @@
+export type Mode = 'integer' | 'decimal' | 'dice';
+
+export interface Roll {
+  value: number;
+  mode: Mode;
+  min: number;
+  max: number;
+  at: string;
+}
+
+function cryptoRandom(): number {
+  const array = new Uint32Array(1);
+  crypto.getRandomValues(array);
+  return (array[0] ?? 0) / 0xffffffff;
+}
+
+export function roll(min: number, max: number, mode: Mode): Roll {
+  const lo = Math.min(min, max);
+  const hi = Math.max(min, max);
+  let value: number;
+  if (mode === 'integer' || mode === 'dice') {
+    value = Math.floor(cryptoRandom() * (hi - lo + 1)) + lo;
+  } else {
+    value = cryptoRandom() * (hi - lo) + lo;
+  }
+  return {
+    value,
+    mode,
+    min: lo,
+    max: hi,
+    at: new Date().toISOString(),
+  };
+}
+
+export const DICE_FACES: Record<number, string> = {
+  1: 'dice-1',
+  2: 'dice-2',
+  3: 'dice-3',
+  4: 'dice-4',
+  5: 'dice-5',
+  6: 'dice-6',
+};

package/dist/scaffolds/notis-random/lib/roll-record.ts

@@ -0,0 +1,102 @@
+import type { Mode } from '@/lib/rng';
+
+export interface RollDocument {
+  id: string;
+  title: string;
+  properties?: Record<string, unknown>;
+  createdAt?: string | null;
+  created_at?: string | null;
+  created_time?: string | null;
+  lastEditedTime?: string | null;
+  last_edited_time?: string | null;
+  updated_at?: string | null;
+}
+
+function readString(value: unknown): string | null {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : null;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (value && typeof value === 'object') {
+    const record = value as Record<string, unknown>;
+    if (typeof record.name === 'string') {
+      return record.name;
+    }
+    if (typeof record.start === 'string') {
+      return record.start;
+    }
+  }
+  return null;
+}
+
+function readNumber(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  const stringValue = readString(value);
+  if (!stringValue) {
+    return null;
+  }
+  const parsed = Number(stringValue);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function readMode(value: unknown): Mode {
+  const raw = readString(value)?.toLowerCase();
+  if (raw === 'integer' || raw === 'decimal' || raw === 'dice') {
+    return raw;
+  }
+  return 'integer';
+}
+
+function readTimestamp(doc: RollDocument): string {
+  return (
+    readString(doc.properties?.['Rolled At']) ||
+    doc.createdAt ||
+    doc.created_at ||
+    doc.created_time ||
+    doc.lastEditedTime ||
+    doc.last_edited_time ||
+    doc.updated_at ||
+    ''
+  );
+}
+
+function sortTimestamp(value: string): number {
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export interface RollRecord {
+  id: string;
+  value: number;
+  mode: Mode;
+  min: number | null;
+  max: number | null;
+  at: string;
+}
+
+export function normalizeRollRecord(doc: RollDocument): RollRecord {
+  const value =
+    readNumber(doc.properties?.['Value']) ??
+    readNumber(doc.properties?.['Name']) ??
+    readNumber(doc.title) ??
+    0;
+
+  return {
+    id: doc.id,
+    value,
+    mode: readMode(doc.properties?.['Mode']),
+    min: readNumber(doc.properties?.['Min']),
+    max: readNumber(doc.properties?.['Max']),
+    at: readTimestamp(doc),
+  };
+}
+
+export function sortRollRecordsDesc(a: RollRecord, b: RollRecord): number {
+  return sortTimestamp(b.at) - sortTimestamp(a.at);
+}

package/dist/scaffolds/notis-random/lib/utils.ts

@@ -0,0 +1,25 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
+
+export function formatNumber(value: number): string {
+  if (Number.isInteger(value)) return value.toString();
+  return value.toFixed(4).replace(/0+$/, '').replace(/\.$/, '');
+}
+
+export function relativeTime(iso: string | null | undefined): string {
+  if (!iso) return '';
+  const then = new Date(iso).getTime();
+  if (Number.isNaN(then)) return '';
+  const diffSeconds = Math.round((Date.now() - then) / 1000);
+  if (diffSeconds < 5) return 'just now';
+  if (diffSeconds < 60) return `${diffSeconds}s ago`;
+  const diffMinutes = Math.round(diffSeconds / 60);
+  if (diffMinutes < 60) return `${diffMinutes}m ago`;
+  const diffHours = Math.round(diffMinutes / 60);
+  if (diffHours < 24) return `${diffHours}h ago`;
+  return new Date(iso).toLocaleDateString();
+}

package/dist/scaffolds/notis-random/notis.config.ts

@@ -0,0 +1,43 @@
+import { defineNotisApp } from '@notis/sdk/config';
+
+export default defineNotisApp({
+  name: 'notis-random',
+  title: 'Random Number Generator',
+  description: 'Generate random numbers with configurable bounds, and keep a history of everything you rolled.',
+  icon: 'phosphor:dice-five',
+  author: { name: 'Notis' },
+  categories: ['Personal'],
+  tagline: 'Roll dice, keep history.',
+  versionNotes: 'Initial scaffold release.',
+
+  databases: ['rolls'],
+
+  routes: [
+    {
+      path: '/',
+      slug: 'home',
+      name: 'Generator',
+      icon: 'phosphor:sparkle',
+      default: true,
+    },
+    {
+      path: '/history',
+      slug: 'history',
+      name: 'History',
+      icon: 'phosphor:clock-counter-clockwise',
+      collection: {
+        database: 'rolls',
+        titleProperty: 'Value',
+        sidebar: {
+          mode: 'flat-list',
+          allowCreate: false,
+        },
+      },
+    },
+  ],
+
+  tools: [
+    'LOCAL_NOTIS_DATABASE_QUERY',
+    'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS',
+  ],
+});

package/dist/scaffolds/notis-random/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@notis-apps/notis-random",
+  "version": "0.1.0",
+  "notisAppVersion": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@notis/sdk": "file:../../packages/sdk",
+    "@phosphor-icons/react": "^2.1.10",
+    "clsx": "^2.1.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwind-merge": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "autoprefixer": "^10.4.0",
+    "postcss": "^8.4.0",
+    "tailwindcss": "^3.4.0",
+    "tailwindcss-animate": "^1.0.7",
+    "typescript": "^5.5.0",
+    "vite": "^6.0.0"
+  }
+}

package/dist/scaffolds/notis-random/postcss.config.mjs

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

package/dist/scaffolds/notis-random/src/dev-main.tsx

@@ -0,0 +1,70 @@
+// Dev entrypoint: mounts the app pages with a tiny hash-router and the mock
+// runtime. Not used in production — `vite build` uses .notis/_entry.tsx.
+import { StrictMode, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { NotisProvider } from '@notis/sdk';
+import AppShell from '../app/layout';
+import HomePage from '../app/page';
+import HistoryPage from '../app/history/page';
+import { installMockRuntime, setMockRoute } from './mock-runtime';
+
+const runtime = installMockRuntime(hashRoute());
+
+function hashRoute(): 'home' | 'history' {
+  return window.location.hash === '#/history' ? 'history' : 'home';
+}
+
+function DevApp() {
+  const [route, setRoute] = useState<'home' | 'history'>(hashRoute());
+
+  useEffect(() => {
+    const onChange = () => {
+      const next = hashRoute();
+      setRoute(next);
+      setMockRoute(next);
+    };
+    window.addEventListener('hashchange', onChange);
+    return () => window.removeEventListener('hashchange', onChange);
+  }, []);
+
+  const Page = route === 'history' ? HistoryPage : HomePage;
+
+  return (
+    <AppShell>
+      <div className="mx-auto max-w-4xl px-4 pt-4">
+        <nav className="flex items-center gap-2 rounded-full border border-border bg-card p-1 text-sm w-fit">
+          <a
+            href="#/"
+            className={
+              (route === 'home' ? 'bg-accent text-accent-foreground ' : 'text-muted-foreground hover:text-foreground ') +
+              'rounded-full px-3 py-1 transition'
+            }
+          >
+            Generator
+          </a>
+          <a
+            href="#/history"
+            className={
+              (route === 'history' ? 'bg-accent text-accent-foreground ' : 'text-muted-foreground hover:text-foreground ') +
+              'rounded-full px-3 py-1 transition'
+            }
+          >
+            History
+          </a>
+          <span className="pl-2 pr-3 text-[10px] uppercase tracking-wide text-muted-foreground">dev preview</span>
+        </nav>
+      </div>
+      <Page />
+    </AppShell>
+  );
+}
+
+const root = document.getElementById('root');
+if (!root) throw new Error('#root element missing from index.html');
+createRoot(root).render(
+  <StrictMode>
+    <NotisProvider runtime={runtime}>
+      <DevApp />
+    </NotisProvider>
+  </StrictMode>,
+);

package/dist/scaffolds/notis-random/src/mock-runtime.ts

@@ -0,0 +1,128 @@
+import type { NotisRuntime } from '@notis/sdk';
+
+interface MockDoc {
+  id: string;
+  title: string;
+  properties: Record<string, unknown>;
+  icon?: string | null;
+  databaseSlug?: string;
+  createdAt?: string | null;
+  lastEditedTime?: string | null;
+  contentBlocknote?: Array<Record<string, unknown>> | null;
+  contentMarkdown?: string | null;
+  plainText?: string | null;
+}
+
+const STATE: Record<string, MockDoc[]> = { rolls: [] };
+
+declare global {
+  interface Window {
+    __NOTIS_RANDOM_RUNTIME__?: NotisRuntime;
+  }
+}
+
+export function installMockRuntime(initialRoute: 'home' | 'history' = 'home'): NotisRuntime {
+  const runtime: NotisRuntime = {
+    app: {
+      id: 'dev-notis-random',
+      name: 'Random Number Generator',
+      icon: 'phosphor:dice-five',
+      description: 'Dev preview — data is in-memory only.',
+    },
+    route: currentRoute(initialRoute),
+    context: {},
+
+    listTools: async () => [
+      {
+        name: 'LOCAL_NOTIS_DATABASE_QUERY',
+        inputSchema: { type: 'object', properties: { database_slug: { type: 'string' } } },
+      },
+      {
+        name: 'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS',
+        inputSchema: { type: 'object', properties: {} },
+      },
+    ],
+    callTool: async <TResult = unknown>(name: string, args?: Record<string, unknown>): Promise<TResult> => {
+      if (name === 'LOCAL_NOTIS_DATABASE_QUERY') {
+        const request = args ?? {};
+        const databaseSlug = typeof request.database_slug === 'string' ? request.database_slug : 'rolls';
+        const query = request.query && typeof request.query === 'object'
+          ? request.query as Record<string, unknown>
+          : {};
+        const offset = typeof request.offset === 'number' ? request.offset : 0;
+        const all = STATE[databaseSlug] ?? [];
+        const sliced = all.slice(offset);
+        const pageSize = typeof query.page_size === 'number' ? query.page_size : undefined;
+        return { documents: typeof pageSize === 'number' ? sliced.slice(0, pageSize) : sliced } as TResult;
+      }
+
+      if (name === 'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS') {
+        const request = args ?? {};
+        const docs = STATE.rolls ?? [];
+        const now = new Date().toISOString();
+        const documentId = typeof request.document_id === 'string' ? request.document_id : undefined;
+        const existing = documentId ? docs.find((d) => d.id === documentId) : undefined;
+        const controlKeys = new Set(['document_id', 'title']);
+        const properties = Object.fromEntries(
+          Object.entries(request).filter(([key]) => !controlKeys.has(key)),
+        );
+        const doc: MockDoc = {
+          id: existing?.id ?? `dev-rolls-${Date.now()}`,
+          title: typeof request.title === 'string' ? request.title : existing?.title ?? 'Untitled',
+          properties: { ...(existing?.properties ?? {}), ...properties },
+          databaseSlug: 'rolls',
+          icon: null,
+          createdAt: existing?.createdAt ?? now,
+          lastEditedTime: now,
+        };
+        if (existing) docs[docs.indexOf(existing)] = doc;
+        else docs.unshift(doc);
+        STATE.rolls = docs;
+        return { status: 'success', document: doc } as TResult;
+      }
+
+      throw new Error(`Tool calls unavailable in dev preview (${name}).`);
+    },
+
+    request: async () => {
+      throw new Error('Backend requests unavailable in dev preview.');
+    },
+  };
+
+  window.__NOTIS_RANDOM_RUNTIME__ = runtime;
+  return runtime;
+}
+
+export function setMockRoute(route: 'home' | 'history') {
+  if (window.__NOTIS_RANDOM_RUNTIME__) {
+    window.__NOTIS_RANDOM_RUNTIME__.route = currentRoute(route);
+  }
+}
+
+function currentRoute(route: 'home' | 'history') {
+  if (route === 'history') {
+    return {
+      slug: 'history',
+      path: '/history',
+      name: 'History',
+      icon: null,
+      parentSlug: null,
+      default: false,
+      collection: {
+        database: 'rolls',
+        titleProperty: 'Value',
+        parentProperty: null,
+        sidebar: { mode: 'flat-list' as const, allowCreate: false },
+      },
+    };
+  }
+  return {
+    slug: 'home',
+    path: '/',
+    name: 'Generator',
+    icon: 'phosphor:sparkle',
+    parentSlug: null,
+    default: true,
+    collection: null,
+  };
+}

package/dist/scaffolds/notis-random/tailwind.config.ts

@@ -0,0 +1,43 @@
+import type { Config } from 'tailwindcss';
+import tailwindAnimate from 'tailwindcss-animate';
+
+const config: Config = {
+  darkMode: ['class'],
+  content: ['./app/**/*.{ts,tsx}', './lib/**/*.{ts,tsx}'],
+  theme: {
+    extend: {
+      colors: {
+        border: 'hsl(var(--border))',
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+      },
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+      fontFamily: {
+        mono: ['ui-monospace', 'SFMono-Regular', 'Menlo', 'monospace'],
+      },
+    },
+  },
+  plugins: [tailwindAnimate],
+};
+
+export default config;

package/dist/scaffolds/notis-random/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "preserveSymlinks": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "types": ["vite/client", "node"],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/scaffolds/notis-random/vite.config.ts

@@ -0,0 +1,11 @@
+import { notisViteConfig } from '@notis/sdk/vite';
+import react from '@vitejs/plugin-react';
+import { defineConfig, type UserConfig } from 'vite';
+import appConfig from './notis.config';
+
+const libConfig = notisViteConfig(appConfig) as unknown as UserConfig;
+
+export default defineConfig({
+  ...libConfig,
+  plugins: [react(), ...((libConfig.plugins as UserConfig['plugins']) ?? [])],
+});