@assistkick/create 1.0.0

package/templates/product-system/packages/shared/lib/constants.ts

@@ -0,0 +1,327 @@
+/**
+ * Constants for the interview system knowledge graph.
+ * Defines node types, valid edge relations, required sections per type,
+ * and scoring weights for completeness calculation.
+ */
+
+// All valid node types with their ID prefixes
+export const NODE_TYPES = {
+  feature: 'feat',
+  component: 'comp',
+  data_entity: 'data',
+  decision: 'dec',
+  tech_choice: 'tech',
+  non_functional_requirement: 'nfr',
+  design_token: 'dtok',
+  design_pattern: 'dpat',
+  user_role: 'role',
+  flow: 'flow',
+  assumption: 'asmp',
+  open_question: 'oq',
+};
+
+// Required sections per node type — completeness scoring checks these
+export const REQUIRED_SECTIONS = {
+  feature: ['Description', 'Acceptance Criteria', 'Open Questions'],
+  component: ['Description', 'Responsibilities', 'Tech', 'Exposes', 'Consumes'],
+  data_entity: ['Description', 'Fields', 'Used By'],
+  decision: ['Description', 'Rationale', 'Alternatives Considered', 'Affects'],
+  tech_choice: ['Description', 'Category', 'Constraints', 'Chosen For'],
+  non_functional_requirement: ['Description', 'Category', 'Metric', 'Affects'],
+  design_token: ['Category', 'Value', 'Used In'],
+  design_pattern: ['Description', 'When To Use', 'Examples'],
+  user_role: ['Description', 'Goals', 'Permissions'],
+  flow: ['Description', 'Steps', 'Actors'],
+  assumption: ['Description', 'Confidence', 'Depends On'],
+  open_question: ['Description', 'Blocking', 'Affects'],
+};
+
+// Valid edge relation types
+export const VALID_RELATIONS = [
+  'contains',
+  'depends_on',
+  'governed_by',
+  'constrained_by',
+  'implemented_with',
+  'reads_writes',
+  'exposes',
+  'consumes',
+  'performed_by',
+  'escalates_to',
+  'relates_to',
+];
+
+// Valid node statuses
+export const VALID_STATUSES = ['draft', 'partially_defined', 'defined'];
+
+// Valid priority levels
+export const VALID_PRIORITIES = ['low', 'medium', 'high', 'blocking'];
+
+// Valid feature kind values
+export const VALID_FEATURE_KINDS = ['new', 'improvement', 'bugfix'];
+
+// Scoring weights per node type — each rule is { check, weight, description }
+// check receives (frontmatter, sections) and returns boolean
+export const SCORING_RULES = {
+  feature: [
+    {
+      weight: 0.2,
+      description: 'Description present and > 50 chars',
+      check: (_fm, sections) => {
+        const desc = sections['Description'] || '';
+        return desc.trim().length > 50;
+      },
+    },
+    {
+      weight: 0.3,
+      description: 'At least 1 acceptance criterion',
+      check: (_fm, sections) => {
+        const ac = sections['Acceptance Criteria'] || '';
+        return ac.trim().split('\n').filter(l => l.trim().startsWith('-')).length >= 1;
+      },
+    },
+    {
+      weight: 0.3,
+      description: 'No open questions',
+      check: (_fm, sections) => {
+        const oq = sections['Open Questions'] || '';
+        return oq.trim().split('\n').filter(l => l.trim().startsWith('- [ ]')).length === 0;
+      },
+    },
+    {
+      weight: 0.2,
+      description: 'Status is defined',
+      check: (fm, _sections) => fm.status === 'defined',
+    },
+  ],
+  component: [
+    {
+      weight: 0.2,
+      description: 'Description present and > 50 chars',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 50,
+    },
+    {
+      weight: 0.2,
+      description: 'Responsibilities listed',
+      check: (_fm, sections) => {
+        const r = sections['Responsibilities'] || '';
+        return r.trim().split('\n').filter(l => l.trim().startsWith('-')).length >= 1;
+      },
+    },
+    {
+      weight: 0.2,
+      description: 'Tech specified',
+      check: (_fm, sections) => (sections['Tech'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.2,
+      description: 'Exposes defined',
+      check: (_fm, sections) => (sections['Exposes'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.2,
+      description: 'Consumes defined',
+      check: (_fm, sections) => (sections['Consumes'] || '').trim().length > 0,
+    },
+  ],
+  data_entity: [
+    {
+      weight: 0.3,
+      description: 'Description present and > 50 chars',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 50,
+    },
+    {
+      weight: 0.4,
+      description: 'Fields listed',
+      check: (_fm, sections) => {
+        const f = sections['Fields'] || '';
+        return f.trim().split('\n').filter(l => l.trim().startsWith('-')).length >= 1;
+      },
+    },
+    {
+      weight: 0.3,
+      description: 'Used By specified',
+      check: (_fm, sections) => (sections['Used By'] || '').trim().length > 0,
+    },
+  ],
+  decision: [
+    {
+      weight: 0.25,
+      description: 'Description present and > 50 chars',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 50,
+    },
+    {
+      weight: 0.3,
+      description: 'Rationale provided',
+      check: (_fm, sections) => (sections['Rationale'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.25,
+      description: 'Alternatives considered',
+      check: (_fm, sections) => {
+        const a = sections['Alternatives Considered'] || '';
+        return a.trim().split('\n').filter(l => l.trim().startsWith('-')).length >= 1;
+      },
+    },
+    {
+      weight: 0.2,
+      description: 'Affects listed',
+      check: (_fm, sections) => (sections['Affects'] || '').trim().length > 0,
+    },
+  ],
+  tech_choice: [
+    {
+      weight: 0.25,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.25,
+      description: 'Category specified',
+      check: (_fm, sections) => (sections['Category'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.25,
+      description: 'Constraints listed',
+      check: (_fm, sections) => (sections['Constraints'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.25,
+      description: 'Chosen For explained',
+      check: (_fm, sections) => (sections['Chosen For'] || '').trim().length > 20,
+    },
+  ],
+  non_functional_requirement: [
+    {
+      weight: 0.25,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.25,
+      description: 'Category specified',
+      check: (_fm, sections) => (sections['Category'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.25,
+      description: 'Metric defined',
+      check: (_fm, sections) => (sections['Metric'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.25,
+      description: 'Affects listed',
+      check: (_fm, sections) => (sections['Affects'] || '').trim().length > 0,
+    },
+  ],
+  design_token: [
+    {
+      weight: 0.33,
+      description: 'Category specified',
+      check: (_fm, sections) => (sections['Category'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.34,
+      description: 'Value defined',
+      check: (_fm, sections) => (sections['Value'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.33,
+      description: 'Used In listed',
+      check: (_fm, sections) => (sections['Used In'] || '').trim().length > 0,
+    },
+  ],
+  design_pattern: [
+    {
+      weight: 0.35,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.35,
+      description: 'When To Use explained',
+      check: (_fm, sections) => (sections['When To Use'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.3,
+      description: 'Examples provided',
+      check: (_fm, sections) => (sections['Examples'] || '').trim().length > 0,
+    },
+  ],
+  user_role: [
+    {
+      weight: 0.35,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.35,
+      description: 'Goals listed',
+      check: (_fm, sections) => {
+        const g = sections['Goals'] || '';
+        return g.trim().split('\n').filter(l => l.trim().startsWith('-')).length >= 1;
+      },
+    },
+    {
+      weight: 0.3,
+      description: 'Permissions defined',
+      check: (_fm, sections) => (sections['Permissions'] || '').trim().length > 0,
+    },
+  ],
+  flow: [
+    {
+      weight: 0.3,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.4,
+      description: 'Steps listed',
+      check: (_fm, sections) => {
+        const s = sections['Steps'] || '';
+        return s.trim().split('\n').filter(l => l.trim().match(/^\d+\.|^-/)).length >= 2;
+      },
+    },
+    {
+      weight: 0.3,
+      description: 'Actors specified',
+      check: (_fm, sections) => (sections['Actors'] || '').trim().length > 0,
+    },
+  ],
+  assumption: [
+    {
+      weight: 0.4,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.3,
+      description: 'Confidence level set',
+      check: (_fm, sections) => (sections['Confidence'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.3,
+      description: 'Depends On specified',
+      check: (_fm, sections) => (sections['Depends On'] || '').trim().length > 0,
+    },
+  ],
+  open_question: [
+    {
+      weight: 0.4,
+      description: 'Description present',
+      check: (_fm, sections) => (sections['Description'] || '').trim().length > 20,
+    },
+    {
+      weight: 0.3,
+      description: 'Blocking status set',
+      check: (_fm, sections) => (sections['Blocking'] || '').trim().length > 0,
+    },
+    {
+      weight: 0.3,
+      description: 'Affects listed',
+      check: (_fm, sections) => (sections['Affects'] || '').trim().length > 0,
+    },
+  ],
+};
+
+// Optional sections that any node can have
+export const COMMON_OPTIONAL_SECTIONS = ['Resolved Questions', 'Notes', 'Relations'];

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

@@ -0,0 +1,81 @@
+/**
+ * Database connection via Drizzle ORM.
+ * Supports Turso cloud (when TURSO_DATABASE_URL + TURSO_AUTH_TOKEN are set)
+ * or local SQLite at data/local.db (default, zero-config).
+ * Lazy initialization — connection established on first query, not at import time.
+ */
+
+import { createClient } from '@libsql/client';
+import { drizzle } from 'drizzle-orm/libsql';
+import { config } from 'dotenv';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync, mkdirSync } from 'node:fs';
+import * as schema from '../db/schema.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Walk up from packages/shared/lib/ (or build/lib/) to find product-system/
+let PROJECT_ROOT = join(__dirname, '..');
+while (PROJECT_ROOT !== dirname(PROJECT_ROOT)) {
+  if (existsSync(join(PROJECT_ROOT, 'pnpm-workspace.yaml'))) break;
+  PROJECT_ROOT = dirname(PROJECT_ROOT);
+}
+const ENV_PATH = join(PROJECT_ROOT, '.env');
+
+let _db = null;
+let _client = null;
+
+/**
+ * Returns the project root path (directory containing pnpm-workspace.yaml).
+ */
+export const getProjectRoot = () => PROJECT_ROOT;
+
+/**
+ * Get the Drizzle database instance. Creates it lazily on first call.
+ * Uses Turso if TURSO_DATABASE_URL and TURSO_AUTH_TOKEN are set,
+ * otherwise falls back to a local SQLite file at data/local.db.
+ */
+export const getDb = () => {
+  if (_db) return _db;
+
+  // Load .env file if it exists (local dev). In production (Docker/Coolify),
+  // env vars are injected directly — no .env file needed.
+  if (existsSync(ENV_PATH)) {
+    config({ path: ENV_PATH, quiet: true });
+  }
+
+  const tursoUrl = process.env.TURSO_DATABASE_URL;
+  const tursoAuthToken = process.env.TURSO_AUTH_TOKEN;
+
+  let connectionUrl: string;
+  let connectionAuthToken: string | undefined;
+
+  if (tursoUrl && tursoAuthToken) {
+    connectionUrl = tursoUrl;
+    connectionAuthToken = tursoAuthToken;
+  } else {
+    // Local SQLite fallback — create data/ directory if needed
+    const dataDir = join(PROJECT_ROOT, 'data');
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+    }
+    connectionUrl = `file:${join(dataDir, 'local.db')}`;
+    connectionAuthToken = undefined;
+  }
+
+  _client = createClient({ url: connectionUrl, authToken: connectionAuthToken });
+  _db = drizzle(_client, { schema });
+
+  return _db;
+};
+
+/**
+ * Close the database connection. Useful for cleanup in tests.
+ */
+export const closeDb = () => {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _db = null;
+  }
+};

package/templates/product-system/packages/shared/lib/git_workflow.ts

@@ -0,0 +1,110 @@
+/**
+ * GitWorkflow — handles worktree creation/cleanup, rebase, merge, branch management.
+ */
+
+import { join } from 'node:path';
+
+export class GitWorkflow {
+  constructor({ claudeService, projectRoot, worktreesDir, log }) {
+    this.claudeService = claudeService;
+    this.projectRoot = projectRoot;
+    this.worktreesDir = worktreesDir;
+    this.log = log;
+  }
+
+  /**
+   * Returns list of uncommitted changed files in the main repo, or empty array if clean.
+   */
+  getDirtyFiles = async () => {
+    const result = await this.claudeService.spawnCommand('git', ['status', '--porcelain'], this.projectRoot);
+    if (!result.trim()) return [];
+    return result.trim().split('\n').map(line => line.trim());
+  };
+
+  createWorktree = async (featureId) => {
+    const worktreePath = join(this.worktreesDir, featureId);
+    this.log('DEVELOP', `Creating worktree at ${worktreePath} (branch: feature/${featureId})`);
+    this.log('DEVELOP', `PROJECT_ROOT=${this.projectRoot}`);
+
+    // Remove leftover worktree from a previous failed/aborted pipeline
+    await this.claudeService.spawnCommand('git', ['worktree', 'remove', '--force', worktreePath], this.projectRoot).catch(() => {});
+    // Delete leftover branch
+    await this.claudeService.spawnCommand('git', ['branch', '-D', `feature/${featureId}`], this.projectRoot).catch(() => {});
+
+    await this.claudeService.spawnCommand('git', ['worktree', 'add', worktreePath, '-b', `feature/${featureId}`], this.projectRoot);
+    this.log('DEVELOP', `Worktree created successfully`);
+    return worktreePath;
+  };
+
+  removeWorktree = async (worktreePath) => {
+    await this.claudeService.spawnCommand('git', ['worktree', 'remove', '--force', worktreePath], this.projectRoot).catch(err => {
+      this.log('PIPELINE', `Worktree cleanup failed (non-fatal): ${err.message}`);
+    });
+  };
+
+  deleteBranch = async (featureId, force = false) => {
+    const flag = force ? '-D' : '-d';
+    await this.claudeService.spawnCommand('git', ['branch', flag, `feature/${featureId}`], this.projectRoot).catch(err => {
+      this.log('PIPELINE', `Branch cleanup failed (non-fatal): ${err.message}`);
+    });
+  };
+
+  commitChanges = async (featureId, worktreePath) => {
+    const statusResult = await this.claudeService.spawnCommand('git', ['status', '--porcelain'], worktreePath);
+    if (statusResult.trim()) {
+      this.log('PIPELINE', `Committing developer changes for ${featureId}...`);
+      await this.claudeService.spawnCommand('git', ['add', '-A'], worktreePath);
+      await this.claudeService.spawnCommand('git', ['commit', '-m', `feat(${featureId}): implement ${featureId}`], worktreePath);
+      this.log('PIPELINE', `Developer changes committed for ${featureId}`);
+    } else {
+      this.log('PIPELINE', `No uncommitted changes found for ${featureId} (developer may have committed already)`);
+    }
+  };
+
+  rebaseBranch = async (featureId, worktreePath) => {
+    this.log('PIPELINE', `Rebasing feature/${featureId} onto main...`);
+    try {
+      await this.claudeService.spawnCommand('git', ['rebase', 'main'], worktreePath);
+      this.log('PIPELINE', `Rebase succeeded for ${featureId}`);
+    } catch (rebaseErr) {
+      this.log('PIPELINE', `Rebase conflict for ${featureId} — aborting and attempting merge instead`);
+      await this.claudeService.spawnCommand('git', ['rebase', '--abort'], worktreePath).catch(() => {});
+      try {
+        await this.claudeService.spawnCommand('git', ['merge', 'main', '-m', `merge main into feature/${featureId}`], worktreePath);
+        this.log('PIPELINE', `Merge main into feature/${featureId} succeeded`);
+      } catch (mergeErr) {
+        this.log('PIPELINE', `WARN: Could not integrate main into ${featureId}: ${mergeErr.message}`);
+      }
+    }
+  };
+
+  mergeBranch = async (featureId) => {
+    this.log('PIPELINE', `Merging feature/${featureId} into parent branch...`);
+    await this.claudeService.spawnCommand('git', ['merge', `feature/${featureId}`], this.projectRoot);
+    this.log('PIPELINE', `Merge succeeded`);
+  };
+
+  fixMergeConflicts = async (featureId) => {
+    await this.claudeService.spawnClaude(
+      `There are merge conflicts after merging feature/${featureId}. Resolve all conflicts and commit.`,
+      this.projectRoot,
+      `merge-fix:${featureId}`,
+    );
+    const mergedBranches = await this.claudeService.spawnCommand('git', ['branch', '--merged', 'HEAD', '--list', `feature/${featureId}`], this.projectRoot);
+    return mergedBranches.trim().length > 0;
+  };
+
+  stash = async () => {
+    const stashResult = await this.claudeService.spawnCommand('git', ['stash', '--include-untracked'], this.projectRoot);
+    const stashed = !stashResult.includes('No local changes to save');
+    if (stashed) {
+      this.log('PIPELINE', `Stashed local changes before merge`);
+    }
+    return stashed;
+  };
+
+  unstash = async () => {
+    await this.claudeService.spawnCommand('git', ['stash', 'pop'], this.projectRoot);
+    this.log('PIPELINE', `Restored stashed local changes`);
+  };
+}

package/templates/product-system/packages/shared/lib/graph.ts

@@ -0,0 +1,186 @@
+/**
+ * Graph operations backed by Drizzle/Turso.
+ * Replaces the old filesystem-based graph.json read/write.
+ * All query functions are async (Turso uses async driver).
+ */
+
+import { eq, and } from 'drizzle-orm';
+import { getDb, getProjectRoot as _getProjectRoot } from './db.js';
+import { nodes, edges } from '../db/schema.js';
+
+export { getProjectRoot } from './db.js';
+
+/**
+ * Read the full graph structure from the database.
+ * Returns the same shape as the old graph.json: { version, project, nodes, edges }.
+ */
+export const readGraph = async (projectId?: string) => {
+  const db = getDb();
+  const allNodes = projectId
+    ? await db.select().from(nodes).where(eq(nodes.projectId, projectId))
+    : await db.select().from(nodes);
+
+  const allEdges = await db.select().from(edges);
+  // When filtering by project, only include edges where both endpoints are in the filtered set
+  const filteredEdges = projectId
+    ? (() => { const ids = new Set(allNodes.map(n => n.id)); return allEdges.filter(e => ids.has(e.fromId) && ids.has(e.toId)); })()
+    : allEdges;
+
+  return {
+    version: '1.0',
+    project: {
+      name: '',
+      description: '',
+      created_at: '',
+      updated_at: '',
+    },
+    nodes: allNodes.map(n => ({
+      id: n.id,
+      type: n.type,
+      name: n.name,
+      status: n.status,
+      completeness: n.completeness,
+      open_questions_count: n.openQuestionsCount,
+      ...(n.kind ? { kind: n.kind } : {}),
+      created_at: n.createdAt,
+      updated_at: n.updatedAt,
+    })),
+    edges: filteredEdges.map(e => ({
+      from: e.fromId,
+      to: e.toId,
+      relation: e.relation,
+    })),
+  };
+};
+
+/**
+ * Write the full graph to the database (replaces all nodes and edges).
+ * Used by rebuild_index to do a full replace.
+ */
+export const writeGraph = async (graph, projectId?: string) => {
+  const db = getDb();
+
+  await db.transaction(async (tx) => {
+    // Clear existing data
+    await tx.delete(edges);
+    await tx.delete(nodes);
+
+    // Insert all nodes
+    for (const n of graph.nodes) {
+      await tx.insert(nodes).values({
+        id: n.id,
+        type: n.type,
+        name: n.name,
+        status: n.status,
+        priority: n.priority || 'medium',
+        completeness: n.completeness,
+        openQuestionsCount: n.open_questions_count,
+        kind: n.kind || null,
+        createdAt: n.created_at,
+        updatedAt: n.updated_at,
+        body: n.body || null,
+        projectId: projectId || n.projectId || null,
+      });
+    }
+
+    // Insert all edges
+    for (const e of graph.edges) {
+      await tx.insert(edges).values({
+        fromId: e.from,
+        relation: e.relation,
+        toId: e.to,
+        projectId: projectId || e.projectId || null,
+      });
+    }
+  });
+};
+
+/**
+ * Patch specific fields on a node by ID.
+ */
+export const patchNode = async (id, fields) => {
+  const db = getDb();
+  const rows = await db.select().from(nodes).where(eq(nodes.id, id));
+  const existing = rows[0];
+
+  if (!existing) {
+    throw new Error(`Node not found in graph: ${id}`);
+  }
+
+  const updates = {};
+  if (fields.status !== undefined) updates.status = fields.status;
+  if (fields.completeness !== undefined) updates.completeness = fields.completeness;
+  if (fields.open_questions_count !== undefined) updates.openQuestionsCount = fields.open_questions_count;
+  if (fields.kind !== undefined) updates.kind = fields.kind;
+  if (fields.name !== undefined) updates.name = fields.name;
+  if (fields.priority !== undefined) updates.priority = fields.priority;
+  if (fields.body !== undefined) updates.body = fields.body;
+  updates.updatedAt = new Date().toISOString();
+
+  await db.update(nodes).set(updates).where(eq(nodes.id, id));
+
+  return { ...existing, ...updates };
+};
+
+/**
+ * Add an edge to the database.
+ */
+export const addEdge = async (from, relation, to, projectId?: string) => {
+  const db = getDb();
+  await db.insert(edges).values({
+    fromId: from,
+    relation,
+    toId: to,
+    projectId: projectId || null,
+  });
+};
+
+/**
+ * Remove an edge from the database.
+ */
+export const removeEdge = async (from, relation, to) => {
+  const db = getDb();
+  const result = await db.delete(edges).where(
+    and(
+      eq(edges.fromId, from),
+      eq(edges.relation, relation),
+      eq(edges.toId, to),
+    )
+  );
+
+  if (result.rowsAffected === 0) {
+    throw new Error(`Edge not found: ${from} --${relation}--> ${to}`);
+  }
+};
+
+/**
+ * Check if a node exists in the database.
+ */
+export const nodeExists = async (id) => {
+  const db = getDb();
+  const rows = await db.select({ id: nodes.id }).from(nodes).where(eq(nodes.id, id));
+  return rows.length > 0;
+};
+
+/**
+ * Get a node's metadata from the database.
+ */
+export const getNode = async (id) => {
+  const db = getDb();
+  const rows = await db.select().from(nodes).where(eq(nodes.id, id));
+  if (rows.length === 0) return null;
+
+  const row = rows[0];
+  return {
+    id: row.id,
+    type: row.type,
+    name: row.name,
+    status: row.status,
+    completeness: row.completeness,
+    open_questions_count: row.openQuestionsCount,
+    ...(row.kind ? { kind: row.kind } : {}),
+    created_at: row.createdAt,
+    updated_at: row.updatedAt,
+    project_id: row.projectId,
+  };
+};