@assistkick/create 1.0.0

package/templates/product-system/packages/frontend/src/utils/auth_validation.test.ts

@@ -0,0 +1,51 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { validateEmail, validatePassword, MIN_PASSWORD_LENGTH } from './auth_validation.ts';
+
+describe('validateEmail', () => {
+  it('returns error for empty string', () => {
+    assert.equal(validateEmail(''), 'Email is required');
+  });
+
+  it('returns error for whitespace-only string', () => {
+    assert.equal(validateEmail('   '), 'Email is required');
+  });
+
+  it('returns error for invalid email format', () => {
+    assert.equal(validateEmail('notanemail'), 'Invalid email format');
+  });
+
+  it('returns error for email without domain', () => {
+    assert.equal(validateEmail('user@'), 'Invalid email format');
+  });
+
+  it('returns error for email without TLD', () => {
+    assert.equal(validateEmail('user@domain'), 'Invalid email format');
+  });
+
+  it('returns undefined for valid email', () => {
+    assert.equal(validateEmail('admin@example.com'), undefined);
+  });
+
+  it('returns undefined for valid email with subdomain', () => {
+    assert.equal(validateEmail('user@mail.example.com'), undefined);
+  });
+});
+
+describe('validatePassword', () => {
+  it('returns error for empty string', () => {
+    assert.equal(validatePassword(''), 'Password is required');
+  });
+
+  it('returns error for short password', () => {
+    assert.equal(validatePassword('1234567'), `Password must be at least ${MIN_PASSWORD_LENGTH} characters`);
+  });
+
+  it('returns undefined for exactly 8 characters', () => {
+    assert.equal(validatePassword('12345678'), undefined);
+  });
+
+  it('returns undefined for long password', () => {
+    assert.equal(validatePassword('a-very-long-password-indeed'), undefined);
+  });
+});

package/templates/product-system/packages/frontend/src/utils/auth_validation.ts

@@ -0,0 +1,19 @@
+/**
+ * Validation utilities for auth forms (registration, login).
+ * Pure functions — no React dependencies.
+ */
+
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export const MIN_PASSWORD_LENGTH = 8;
+
+export const validateEmail = (email: string): string | undefined => {
+  if (!email.trim()) return 'Email is required';
+  if (!EMAIL_REGEX.test(email)) return 'Invalid email format';
+  return undefined;
+};
+
+export const validatePassword = (password: string): string | undefined => {
+  if (!password) return 'Password is required';
+  if (password.length < MIN_PASSWORD_LENGTH) return `Password must be at least ${MIN_PASSWORD_LENGTH} characters`;
+  return undefined;
+};

package/templates/product-system/packages/frontend/src/utils/login_validation.test.ts

@@ -0,0 +1,61 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { validateLoginForm, parseLoginResponse } from './login_validation.ts';
+
+describe('validateLoginForm', () => {
+  it('returns error when email is empty', () => {
+    assert.equal(validateLoginForm('', 'password123'), 'Email and password are required');
+  });
+
+  it('returns error when email is whitespace only', () => {
+    assert.equal(validateLoginForm('  ', 'password123'), 'Email and password are required');
+  });
+
+  it('returns error when password is empty', () => {
+    assert.equal(validateLoginForm('user@example.com', ''), 'Email and password are required');
+  });
+
+  it('returns error when both are empty', () => {
+    assert.equal(validateLoginForm('', ''), 'Email and password are required');
+  });
+
+  it('returns empty string for valid inputs', () => {
+    assert.equal(validateLoginForm('user@example.com', 'password123'), '');
+  });
+
+  it('trims email before checking', () => {
+    assert.equal(validateLoginForm(' user@example.com ', 'pass'), '');
+  });
+});
+
+describe('parseLoginResponse', () => {
+  it('returns user data for successful response', async () => {
+    const mockResp = {
+      ok: true,
+      json: async () => ({ user: { id: '1', email: 'a@b.com', role: 'admin' } }),
+    } as Response;
+
+    const result = await parseLoginResponse(mockResp);
+    assert.deepEqual(result, { user: { id: '1', email: 'a@b.com', role: 'admin' } });
+  });
+
+  it('returns error from API response body', async () => {
+    const mockResp = {
+      ok: false,
+      json: async () => ({ error: 'Invalid email or password' }),
+    } as Response;
+
+    const result = await parseLoginResponse(mockResp);
+    assert.deepEqual(result, { error: 'Invalid email or password' });
+  });
+
+  it('returns generic error when response body is not JSON', async () => {
+    const mockResp = {
+      ok: false,
+      json: async () => { throw new Error('not json'); },
+    } as unknown as Response;
+
+    const result = await parseLoginResponse(mockResp);
+    assert.deepEqual(result, { error: 'Login failed' });
+  });
+});

package/templates/product-system/packages/frontend/src/utils/login_validation.ts

@@ -0,0 +1,24 @@
+/**
+ * Login form validation logic.
+ * Returns an error message string if invalid, or empty string if valid.
+ */
+
+export const validateLoginForm = (email: string, password: string): string => {
+  if (!email.trim() || !password) {
+    return 'Email and password are required';
+  }
+  return '';
+};
+
+/**
+ * Parses the login API response and returns either user data or an error string.
+ */
+export const parseLoginResponse = async (
+  resp: Response
+): Promise<{ user: { id: string; email: string; role: string } } | { error: string }> => {
+  if (!resp.ok) {
+    const data = await resp.json().catch(() => null);
+    return { error: data?.error || 'Login failed' };
+  }
+  return resp.json();
+};

package/templates/product-system/packages/frontend/src/utils/logout.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ApiClient } from '../api/client.ts';
+
+describe('ApiClient.logout', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('calls POST /api/auth/logout with same-origin credentials', async () => {
+    let capturedUrl = '';
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = mock.fn(async (url: any, init?: any) => {
+      capturedUrl = url;
+      capturedInit = init;
+      return { ok: true, json: async () => ({ message: 'Logged out' }) } as Response;
+    }) as any;
+
+    const client = new ApiClient();
+    const result = await client.logout();
+
+    assert.equal(capturedUrl, '/api/auth/logout');
+    assert.equal(capturedInit?.method, 'POST');
+    assert.equal(capturedInit?.credentials, 'same-origin');
+    assert.deepEqual(result, { message: 'Logged out' });
+  });
+
+  it('throws when server returns non-ok response', async () => {
+    globalThis.fetch = mock.fn(async () => {
+      return { ok: false, status: 500 } as Response;
+    }) as any;
+
+    const client = new ApiClient();
+    await assert.rejects(
+      () => client.logout(),
+      (err: Error) => {
+        assert.match(err.message, /Logout failed/);
+        return true;
+      },
+    );
+  });
+
+  it('uses baseUrl when configured', async () => {
+    let capturedUrl = '';
+
+    globalThis.fetch = mock.fn(async (url: any) => {
+      capturedUrl = url;
+      return { ok: true, json: async () => ({ message: 'Logged out' }) } as Response;
+    }) as any;
+
+    const client = new ApiClient('http://localhost:3000');
+    await client.logout();
+
+    assert.equal(capturedUrl, 'http://localhost:3000/api/auth/logout');
+  });
+});

package/templates/product-system/packages/frontend/src/utils/node_sizing.test.ts

@@ -0,0 +1,62 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { clampedRadius, absoluteRadius, nodeRadius, SCALE_FACTOR } from './node_sizing.ts';
+
+describe('clampedRadius', () => {
+  it('returns base of 8 for zero connections', () => {
+    assert.equal(clampedRadius(0), 8);
+  });
+
+  it('scales linearly for low edge counts', () => {
+    assert.equal(clampedRadius(1), 8 + 1.5);
+    assert.equal(clampedRadius(4), 8 + 6);
+  });
+
+  it('caps the scale at 20 for high edge counts', () => {
+    // edgeCount * 1.5 > 20 when edgeCount > 13.33
+    assert.equal(clampedRadius(14), 8 + 20);
+    assert.equal(clampedRadius(100), 8 + 20);
+  });
+
+  it('maximum radius is 28', () => {
+    assert.equal(clampedRadius(999), 28);
+  });
+});
+
+describe('absoluteRadius', () => {
+  it('uses SCALE_FACTOR of 2', () => {
+    assert.equal(SCALE_FACTOR, 2);
+  });
+
+  it('returns minimum of 2 for zero connections', () => {
+    assert.equal(absoluteRadius(0), 2);
+  });
+
+  it('returns edgeCount * 2 for normal counts', () => {
+    assert.equal(absoluteRadius(1), 2);
+    assert.equal(absoluteRadius(5), 10);
+    assert.equal(absoluteRadius(45), 90);
+  });
+
+  it('has no upper cap', () => {
+    assert.equal(absoluteRadius(100), 200);
+  });
+});
+
+describe('nodeRadius', () => {
+  it('uses clamped mode when absoluteSizing is false', () => {
+    assert.equal(nodeRadius(10, false), clampedRadius(10));
+  });
+
+  it('uses absolute mode when absoluteSizing is true', () => {
+    assert.equal(nodeRadius(10, true), absoluteRadius(10));
+  });
+
+  it('default (clamped) caps at 28px', () => {
+    assert.equal(nodeRadius(50, false), 28);
+  });
+
+  it('absolute mode allows large radii', () => {
+    assert.equal(nodeRadius(50, true), 100);
+  });
+});

package/templates/product-system/packages/frontend/src/utils/node_sizing.ts

@@ -0,0 +1,24 @@
+/**
+ * Node radius calculation utilities for the force graph.
+ *
+ * Clamped mode (default): radius = 8 + min(edgeCount * 1.5, 20), capped at 28.
+ * Absolute mode: radius = edgeCount * 2 (no cap), minimum 2px.
+ */
+
+export const SCALE_FACTOR = 2;
+const CLAMPED_BASE = 8;
+const CLAMPED_MAX_SCALE = 20;
+const ABSOLUTE_MIN_RADIUS = 2;
+
+export const clampedRadius = (edgeCount: number): number => {
+  const scale = Math.min(edgeCount * 1.5, CLAMPED_MAX_SCALE);
+  return CLAMPED_BASE + scale;
+};
+
+export const absoluteRadius = (edgeCount: number): number => {
+  return Math.max(edgeCount * SCALE_FACTOR, ABSOLUTE_MIN_RADIUS);
+};
+
+export const nodeRadius = (edgeCount: number, absoluteSizing: boolean): number => {
+  return absoluteSizing ? absoluteRadius(edgeCount) : clampedRadius(edgeCount);
+};

package/templates/product-system/packages/frontend/src/utils/task_status.test.ts

@@ -0,0 +1,53 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { getTaskIcon, getTaskCssClass, shouldShowTaskList, TASK_ICONS } from './task_status.ts';
+
+describe('getTaskIcon', () => {
+  it('returns checkmark for completed', () => {
+    assert.equal(getTaskIcon('completed'), '\u2713');
+  });
+
+  it('returns filled circle for in_progress', () => {
+    assert.equal(getTaskIcon('in_progress'), '\u25CF');
+  });
+
+  it('returns empty circle for pending', () => {
+    assert.equal(getTaskIcon('pending'), '\u25CB');
+  });
+
+  it('falls back to pending icon for unknown status', () => {
+    assert.equal(getTaskIcon('unknown'), TASK_ICONS.pending);
+  });
+});
+
+describe('getTaskCssClass', () => {
+  it('returns correct class for completed', () => {
+    assert.equal(getTaskCssClass('completed'), 'kanban-task-item task-completed');
+  });
+
+  it('returns correct class for in_progress', () => {
+    assert.equal(getTaskCssClass('in_progress'), 'kanban-task-item task-in_progress');
+  });
+
+  it('returns correct class for pending', () => {
+    assert.equal(getTaskCssClass('pending'), 'kanban-task-item task-pending');
+  });
+});
+
+describe('shouldShowTaskList', () => {
+  it('returns true when total > 0', () => {
+    assert.equal(shouldShowTaskList({ total: 4 }), true);
+  });
+
+  it('returns false when total is 0', () => {
+    assert.equal(shouldShowTaskList({ total: 0 }), false);
+  });
+
+  it('returns false for null', () => {
+    assert.equal(shouldShowTaskList(null), false);
+  });
+
+  it('returns false for undefined', () => {
+    assert.equal(shouldShowTaskList(undefined), false);
+  });
+});

package/templates/product-system/packages/frontend/src/utils/task_status.ts

@@ -0,0 +1,14 @@
+export const TASK_ICONS: Record<string, string> = {
+  completed: '\u2713',
+  in_progress: '\u25CF',
+  pending: '\u25CB',
+};
+
+export const getTaskIcon = (status: string): string =>
+  TASK_ICONS[status] ?? TASK_ICONS.pending;
+
+export const getTaskCssClass = (status: string): string =>
+  `kanban-task-item task-${status}`;
+
+export const shouldShowTaskList = (tasks: { total: number } | undefined | null): boolean =>
+  !!tasks && tasks.total > 0;

package/templates/product-system/packages/frontend/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "strict": false,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/templates/product-system/packages/frontend/vite.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+  },
+  server: {
+    port: 5173,
+    strictPort: true,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3000',
+        ws: true,
+      },
+    },
+  },
+});

package/templates/product-system/packages/shared/.env.example

@@ -0,0 +1,3 @@
+# Turso database credentials
+TURSO_DATABASE_URL=libsql://your-database.turso.io
+TURSO_AUTH_TOKEN=your-auth-token

package/templates/product-system/packages/shared/README.md

@@ -0,0 +1 @@
+pnpm db:assign-project -- proj_abc12345

package/templates/product-system/packages/shared/db/migrate.ts

@@ -0,0 +1,32 @@
+/**
+ * Programmatic migration runner for Turso/libSQL.
+ * Uses drizzle-orm/libsql/migrator instead of drizzle-kit CLI,
+ * which has a known bug where it doesn't create __drizzle_migrations.
+ */
+import { config } from 'dotenv';
+config({ path: '../../.env' });
+
+import { migrate } from 'drizzle-orm/libsql/migrator';
+import { drizzle } from 'drizzle-orm/libsql';
+import { createClient } from '@libsql/client';
+
+const client = createClient({
+  url: process.env.TURSO_DATABASE_URL!,
+  authToken: process.env.TURSO_AUTH_TOKEN!,
+});
+
+const db = drizzle(client);
+
+async function main() {
+  console.log('Running migrations...');
+  await migrate(db, { migrationsFolder: './db/migrations' });
+  console.log('Migrations applied successfully.');
+  client.close();
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('Migration failed:', err);
+  client.close();
+  process.exit(1);
+});

package/templates/product-system/packages/shared/db/migrations/0000_dashing_gorgon.sql

@@ -0,0 +1,128 @@
+CREATE TABLE `coherence_reviews` (
+	`id` text PRIMARY KEY NOT NULL,
+	`type` text NOT NULL,
+	`from_id` text,
+	`to_id` text,
+	`relation` text,
+	`proposed_node_type` text,
+	`proposed_node_name` text,
+	`target_node_id` text,
+	`proposed_description` text,
+	`confidence` text,
+	`batch_id` text,
+	`reasoning` text NOT NULL,
+	`status` text NOT NULL,
+	`created_at` text NOT NULL,
+	`resolved_at` text,
+	`project_id` text
+);
+--> statement-breakpoint
+CREATE TABLE `edges` (
+	`from_id` text NOT NULL,
+	`relation` text NOT NULL,
+	`to_id` text NOT NULL,
+	`project_id` text,
+	PRIMARY KEY(`from_id`, `relation`, `to_id`)
+);
+--> statement-breakpoint
+CREATE TABLE `invitations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`email` text NOT NULL,
+	`token_hash` text NOT NULL,
+	`invited_by` text NOT NULL,
+	`expires_at` text NOT NULL,
+	`accepted_at` text,
+	`created_at` text NOT NULL,
+	FOREIGN KEY (`invited_by`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE `kanban` (
+	`node_id` text PRIMARY KEY NOT NULL,
+	`column_name` text NOT NULL,
+	`position` integer NOT NULL,
+	`project_id` text,
+	FOREIGN KEY (`node_id`) REFERENCES `nodes`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE `nodes` (
+	`id` text PRIMARY KEY NOT NULL,
+	`type` text NOT NULL,
+	`name` text NOT NULL,
+	`status` text NOT NULL,
+	`priority` text NOT NULL,
+	`completeness` real DEFAULT 0 NOT NULL,
+	`open_questions_count` integer DEFAULT 0 NOT NULL,
+	`kind` text,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL,
+	`body` text,
+	`project_id` text
+);
+--> statement-breakpoint
+CREATE TABLE `password_reset_tokens` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`token_hash` text NOT NULL,
+	`expires_at` text NOT NULL,
+	`created_at` text NOT NULL,
+	`used_at` text,
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE `pipeline_state` (
+	`feature_id` text PRIMARY KEY NOT NULL,
+	`status` text NOT NULL,
+	`cycle` integer DEFAULT 1 NOT NULL,
+	`tasks_json` text,
+	`tool_calls_json` text,
+	`work_summaries_json` text,
+	`error` text,
+	`updated_at` text NOT NULL,
+	`project_id` text
+);
+--> statement-breakpoint
+CREATE TABLE `projects` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`is_default` integer DEFAULT 0 NOT NULL,
+	`archived_at` text,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `refresh_tokens` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`token_hash` text NOT NULL,
+	`expires_at` text NOT NULL,
+	`created_at` text NOT NULL,
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE `review_meta` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text NOT NULL,
+	`project_id` text
+);
+--> statement-breakpoint
+CREATE TABLE `sessions` (
+	`session_number` integer PRIMARY KEY NOT NULL,
+	`started_at` text NOT NULL,
+	`ended_at` text,
+	`summary` text,
+	`nodes_touched` text,
+	`questions_resolved` integer DEFAULT 0 NOT NULL,
+	`body` text,
+	`project_id` text
+);
+--> statement-breakpoint
+CREATE TABLE `users` (
+	`id` text PRIMARY KEY NOT NULL,
+	`email` text NOT NULL,
+	`password_hash` text NOT NULL,
+	`role` text DEFAULT 'user' NOT NULL,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `users_email_unique` ON `users` (`email`);