@kelpie/server 0.7.0 → 0.9.0

package/src/modules/agent-tasks/resolve.ts

@@ -6,18 +6,19 @@ import type { PgColumn, PgTable } from 'drizzle-orm/pg-core'
 
 import type { Queryable } from '../../runtime/transaction.ts'
 import { companies } from '../companies/schema.ts'
-import { dealPeople, deals } from '../deals/schema.ts'
+import { deals } from '../deals/schema.ts'
 import { decisions } from '../decisions/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
 import { handbookPages } from '../handbook/schema.ts'
 import { candidates, roles } from '../hiring/schema.ts'
 import { notes } from '../notes/schema.ts'
 import { opportunities } from '../opportunities/schema.ts'
-import { partnershipPeople, partnerships } from '../partnerships/schema.ts'
-import { people } from '../people/schema.ts'
+import { partnerships } from '../partnerships/schema.ts'
+import { people, personLinks } from '../people/schema.ts'
 import { pipelineStages } from '../pipelines/schema.ts'
 import { planItems } from '../plans/schema.ts'
 import { positions } from '../positions/schema.ts'
-import { raisePeople, raises } from '../raises/schema.ts'
+import { raises } from '../raises/schema.ts'
 import { isRecordTargetType, resolveTargetNames, targetKey } from '../recordTargets.ts'
 import { workspaces } from '../workspace/schema.ts'
 import type { HandbookPageReference, PromptInputs, RelatedIdList, WorkspaceSignal } from './prompt.ts'
@@ -47,6 +48,7 @@ const DEEP_LINKS: Readonly<Partial<Record<AgentTaskTargetType, string>>> = {
   person: '/people',
   company: '/companies',
   deal: '/deals',
+  enquiry: '/enquiries',
   opportunity: '/opportunities',
   partnership: '/partnerships',
   raise: '/fundraising',
@@ -253,6 +255,33 @@ async function relatedFrom(
   return limitedIds(rows.map((row) => row.id))
 }
 
+/**
+ * The people on one pipeline record, capped and truncation-aware. Uses
+ * `person_links` directly rather than the shared helper because it needs the
+ * limit + 1 semantics of `relatedFrom`.
+ */
+async function personLinkIds(
+  db: Queryable,
+  workspaceId: string,
+  targetType: 'deal' | 'enquiry' | 'opportunity' | 'partnership' | 'raise',
+  targetId: string,
+): Promise<RelatedIdList> {
+  const rows = await db
+    .select({ id: personLinks.personId })
+    .from(personLinks)
+    .where(
+      and(
+        eq(personLinks.workspaceId, workspaceId),
+        eq(personLinks.targetType, targetType),
+        eq(personLinks.targetId, targetId),
+      ),
+    )
+    .orderBy(asc(personLinks.personId))
+    .limit(RELATED_ID_LIMIT + 1)
+
+  return limitedIds(rows.map((row) => row.id))
+}
+
 /**
  * The related record ids `agent-tasks.md`'s context recipe names, per target
  * type: positions for a person, people on a deal, the company behind a raise,
@@ -297,6 +326,12 @@ async function collectRelated(
           deals.id,
           workspaceScoped(deals.workspaceId, deals.companyId),
         ),
+        enquiry_ids: await relatedFrom(
+          db,
+          enquiries,
+          enquiries.id,
+          workspaceScoped(enquiries.workspaceId, enquiries.companyId),
+        ),
         opportunity_ids: await relatedFrom(
           db,
           opportunities,
@@ -326,14 +361,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(deal === undefined ? [] : [deal.companyId]),
-        // The link table has no workspace column; the parent deal was already
-        // resolved inside this workspace, which is what scopes the join.
-        person_ids: await relatedFrom(
-          db,
-          dealPeople,
-          dealPeople.personId,
-          eq(dealPeople.dealId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'deal', targetId),
       }
     }
 
@@ -349,6 +377,21 @@ async function collectRelated(
             ? []
             : [opportunity.companyId],
         ),
+        person_ids: await personLinkIds(db, workspaceId, 'opportunity', targetId),
+      }
+    }
+
+    case 'enquiry': {
+      const [enquiry] = await db
+        .select({ companyId: enquiries.companyId })
+        .from(enquiries)
+        .where(and(eq(enquiries.workspaceId, workspaceId), eq(enquiries.id, targetId)))
+
+      return {
+        company_ids: wholeList(
+          enquiry?.companyId === null || enquiry === undefined ? [] : [enquiry.companyId],
+        ),
+        person_ids: await personLinkIds(db, workspaceId, 'enquiry', targetId),
       }
     }
 
@@ -360,12 +403,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(partnership === undefined ? [] : [partnership.companyId]),
-        person_ids: await relatedFrom(
-          db,
-          partnershipPeople,
-          partnershipPeople.personId,
-          eq(partnershipPeople.partnershipId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'partnership', targetId),
       }
     }
 
@@ -377,12 +415,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(raise === undefined ? [] : [raise.companyId]),
-        person_ids: await relatedFrom(
-          db,
-          raisePeople,
-          raisePeople.personId,
-          eq(raisePeople.raiseId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'raise', targetId),
       }
     }
 
@@ -433,6 +466,13 @@ const SWEEP_TABLES = {
     stageId: deals.stageId,
     summary: deals.summary,
   },
+  enquiry: {
+    table: enquiries,
+    id: enquiries.id,
+    workspaceId: enquiries.workspaceId,
+    stageId: enquiries.stageId,
+    summary: enquiries.summary,
+  },
   opportunity: {
     table: opportunities,
     id: opportunities.id,

package/src/modules/attachedRecords.ts

@@ -5,8 +5,11 @@ import { and, eq } from 'drizzle-orm'
 import type { Queryable } from '../runtime/transaction.ts'
 import * as activityRepository from './activities/repository.ts'
 import * as decisionRepository from './decisions/repository.ts'
+import { formAttachTargets } from './forms/schema.ts'
 import { candidates } from './hiring/schema.ts'
+import * as listRepository from './lists/repository.ts'
 import * as noteRepository from './notes/repository.ts'
+import * as personLinks from './personLinks.ts'
 import * as planRepository from './plans/repository.ts'
 
 /**
@@ -18,7 +21,12 @@ import * as planRepository from './plans/repository.ts'
  * record they described and reappear the day an id is reused.
  *
  * `plan_items` attach the same way but their check constraint allows only the
- * four pipeline types, so they are removed only for those targets.
+ * four pipeline types, so they are removed only for those targets. `person_links`
+ * follows the same rule: it holds a person's involvement in a pipeline record
+ * and its check constraint allows only the four pipeline types, so a deleted
+ * deal/opportunity/raise/partnership sheds its people here. `form_attach_targets`
+ * is the same shape: forms pinning submitters into a pre-existing pipeline
+ * record shed the mapping when the target goes.
  */
 
 /** Target types that can own attached records here. */
@@ -37,7 +45,7 @@ export async function deleteRecordsAttachedTo(
   targetType: AttachableTargetType,
   targetId: string,
 ): Promise<number> {
-  // Sequential, not concurrent: a transaction is one connection, and four
+  // Sequential, not concurrent: a transaction is one connection, and five
   // statements racing down it is not something to rely on for a cheap delete.
   const notes = await noteRepository.deleteForTarget(db, workspaceId, targetType, targetId)
   const activities = await activityRepository.deleteForTarget(db, workspaceId, targetType, targetId)
@@ -45,8 +53,34 @@ export async function deleteRecordsAttachedTo(
   const plans = PLAN_TARGET_TYPES.has(targetType)
     ? await planRepository.deleteForTarget(db, workspaceId, targetType, targetId)
     : 0
+  const links = PLAN_TARGET_TYPES.has(targetType)
+    ? await personLinks.deleteLinksForTarget(db, workspaceId, {
+        targetType: targetType as PipelineKind,
+        targetId,
+      })
+    : 0
+  const attachTargets = PLAN_TARGET_TYPES.has(targetType)
+    ? (
+        await db
+          .delete(formAttachTargets)
+          .where(
+            and(
+              eq(formAttachTargets.workspaceId, workspaceId),
+              eq(formAttachTargets.targetType, targetType),
+              eq(formAttachTargets.targetId, targetId),
+            ),
+          )
+          .returning({ formId: formAttachTargets.formId })
+      ).length
+    : 0
+  const memberships = await listRepository.deleteMembershipsForTarget(
+    db,
+    workspaceId,
+    targetType,
+    targetId,
+  )
 
-  return notes + activities + decisions + plans
+  return notes + activities + decisions + plans + links + attachTargets + memberships
 }
 
 /**

package/src/modules/auth/preferences.ts

@@ -1,4 +1,4 @@
-import type { ThemePreference } from '@kelpie/schemas'
+import type { ListViewPreference, ThemePreference } from '@kelpie/schemas'
 
 /**
  * What an account's preferences are before anyone has saved any, and how a
@@ -17,12 +17,17 @@ export interface PreferenceValues {
   readonly emailDigest: boolean
   readonly mentionEmails: boolean
   readonly productUpdates: boolean
+  readonly listViews: Readonly<Record<string, ListViewPreference>>
 }
 
 /**
  * UTC, not the workspace's zone. An account is global and may belong to several
  * workspaces in different zones, so deriving from one of them would be picking
  * arbitrarily and calling it the person's answer.
+ *
+ * `listViews` starts empty. Each list page falls back to its own default when
+ * the map holds no entry for it, so the person sees the page's built-in shape
+ * until they change it.
  */
 export const DEFAULT_PREFERENCES: PreferenceValues = {
   timezone: 'UTC',
@@ -30,6 +35,7 @@ export const DEFAULT_PREFERENCES: PreferenceValues = {
   emailDigest: true,
   mentionEmails: true,
   productUpdates: false,
+  listViews: {},
 }
 
 export type PreferenceChanges = Partial<PreferenceValues>
@@ -40,6 +46,11 @@ export type PreferenceChanges = Partial<PreferenceValues>
  * The result is always a complete row, which is what makes the write an upsert
  * with no read-modify-write hazard in the caller: the same request applied twice
  * produces the same row.
+ *
+ * `listViews` is treated as one field, so the caller replaces the whole map
+ * rather than merging by key. The UI already holds the current map in the
+ * account-preferences query, so a per-view change becomes a PATCH of the merged
+ * map — the merge lives where the choice was made.
  */
 export function applyPreferenceChanges(
   stored: PreferenceValues | undefined,
@@ -53,5 +64,6 @@ export function applyPreferenceChanges(
     emailDigest: changes.emailDigest ?? current.emailDigest,
     mentionEmails: changes.mentionEmails ?? current.mentionEmails,
     productUpdates: changes.productUpdates ?? current.productUpdates,
+    listViews: changes.listViews ?? current.listViews,
   }
 }

package/src/modules/auth/routes.ts

@@ -1,4 +1,5 @@
 import { THEME_PREFERENCES } from '@kelpie/schemas'
+import type { ListViewPreference } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -59,6 +60,24 @@ const updateAccountBody = z
     path: ['current_password'],
   })
 
+const listViewBody: z.ZodType<ListViewPreference, unknown> = z
+  .strictObject({
+    columns: z.array(z.string()).optional(),
+    mode: z.enum(['list', 'columns']).optional(),
+    grouping: z.string().optional(),
+    scope: z.string().optional(),
+    sort: z.string().optional(),
+  })
+  .transform(
+    (wire): ListViewPreference => ({
+      ...(wire.columns === undefined ? {} : { columns: wire.columns }),
+      ...(wire.mode === undefined ? {} : { mode: wire.mode }),
+      ...(wire.grouping === undefined ? {} : { grouping: wire.grouping }),
+      ...(wire.scope === undefined ? {} : { scope: wire.scope }),
+      ...(wire.sort === undefined ? {} : { sort: wire.sort }),
+    }),
+  )
+
 const updatePreferencesBody = z
   .strictObject({
     timezone: timezoneSchema,
@@ -66,6 +85,7 @@ const updatePreferencesBody = z
     email_digest: z.boolean(),
     mention_emails: z.boolean(),
     product_updates: z.boolean(),
+    list_views: z.record(z.string(), listViewBody),
   })
   .partial()
 
@@ -118,6 +138,7 @@ function preferencesResponse(preferences: PreferenceValues): Record<string, unkn
     email_digest: preferences.emailDigest,
     mention_emails: preferences.mentionEmails,
     product_updates: preferences.productUpdates,
+    list_views: preferences.listViews,
   }
 }
 
@@ -213,6 +234,7 @@ export function mountAuthRoutes(router: Hono, dependencies: AuthRoutesDependenci
       ...(body.email_digest === undefined ? {} : { emailDigest: body.email_digest }),
       ...(body.mention_emails === undefined ? {} : { mentionEmails: body.mention_emails }),
       ...(body.product_updates === undefined ? {} : { productUpdates: body.product_updates }),
+      ...(body.list_views === undefined ? {} : { listViews: body.list_views }),
     })
 
     return context.json(preferencesResponse(preferences))

package/src/modules/auth/schema.ts

@@ -1,6 +1,6 @@
 import { THEME_PREFERENCES } from '@kelpie/schemas'
-import type { ThemePreference } from '@kelpie/schemas'
-import { boolean, pgTable, text } from 'drizzle-orm/pg-core'
+import type { ListViewPreference, ThemePreference } from '@kelpie/schemas'
+import { boolean, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
 
 import { checkOneOf, citext, createdAt, moment, primaryId, updatedAt } from '../../lib/columns.ts'
 
@@ -57,6 +57,16 @@ export const userPreferences = pgTable(
     emailDigest: boolean('email_digest').notNull(),
     mentionEmails: boolean('mention_emails').notNull(),
     productUpdates: boolean('product_updates').notNull(),
+    /**
+     * Per-list column choices, keyed on a stable view id (`people`, `deals`, …).
+     * A view id the client no longer recognises stays untouched here rather than
+     * being cleaned up: the map is small, and the write path is the client
+     * merging its current choice into what it read.
+     */
+    listViews: jsonb('list_views')
+      .$type<Readonly<Record<string, ListViewPreference>>>()
+      .notNull()
+      .default({}),
     updatedAt: updatedAt(),
   },
   (table) => [checkOneOf('user_preferences_theme_check', table.theme, THEME_PREFERENCES)],

package/src/modules/auth/service.ts

@@ -1,5 +1,6 @@
 import { APP_LINK_PATHS, buildAppLink } from '../../lib/appUrl.ts'
 import type { EmailSender } from '../../lib/email.ts'
+import { renderEmail } from '../../lib/emailContent.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
 import { UNIQUE_VIOLATION, postgresErrorCode } from '../../lib/database.ts'
@@ -95,6 +96,7 @@ function toPreferenceValues(record: repository.UserPreferencesRecord): Preferenc
     emailDigest: record.emailDigest,
     mentionEmails: record.mentionEmails,
     productUpdates: record.productUpdates,
+    listViews: record.listViews,
   }
 }
 
@@ -192,11 +194,23 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
 
   function sendVerificationEmail(to: string, token: string): Promise<void> {
     const link = buildAppLink(dependencies.appBaseUrl, APP_LINK_PATHS.verifyEmail, token)
+    const { text, html } = renderEmail(
+      {
+        action: {
+          instructions: 'Confirm this address to finish setting up your account:',
+          buttonText: 'Verify email address',
+          link,
+        },
+        outro: 'The link expires in 24 hours.',
+      },
+      dependencies.appBaseUrl,
+    )
 
     return dependencies.email.send({
       to,
       subject: 'Verify your Kelpie email address',
-      body: `Confirm this address to finish setting up your account:\n\n${link}\n\nThe link expires in 24 hours.`,
+      body: text,
+      html,
     })
   }
 
@@ -320,10 +334,18 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
         })
 
         if (changes.email !== undefined) {
+          const { text, html } = renderEmail(
+            {
+              intro: `Your Kelpie sign-in email changed from ${previousEmail} to ${updated.email}. If you did not make this change, reset your password right away.`,
+            },
+            dependencies.appBaseUrl,
+          )
+
           await dependencies.email.send({
             to: previousEmail,
             subject: 'Your Kelpie sign-in email changed',
-            body: `Your Kelpie sign-in email changed from ${previousEmail} to ${updated.email}. If you did not make this change, reset your password right away.`,
+            body: text,
+            html,
           })
         }
 
@@ -418,11 +440,23 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
       })
 
       const link = buildAppLink(dependencies.appBaseUrl, APP_LINK_PATHS.passwordReset, token)
+      const { text, html } = renderEmail(
+        {
+          action: {
+            instructions: 'Use this link within the hour to choose a new password:',
+            buttonText: 'Reset password',
+            link,
+          },
+          outro: 'If you did not ask for this, ignore it.',
+        },
+        dependencies.appBaseUrl,
+      )
 
       await dependencies.email.send({
         to: user.email,
         subject: 'Reset your Kelpie password',
-        body: `Use this link within the hour to choose a new password:\n\n${link}\n\nIf you did not ask for this, ignore it.`,
+        body: text,
+        html,
       })
     },
 

package/src/modules/companies/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { createCustomFieldValues } from '../custom-fields/index.ts'
 import { companiesEvents } from './events.ts'
 import { mountCompaniesRoutes } from './routes.ts'
 import * as schema from './schema.ts'
@@ -15,7 +16,7 @@ import { registerCompaniesTools } from './tools.ts'
 export function createCompaniesModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'companies',
-    requires: ['workspace', 'activities'],
+    requires: ['workspace', 'activities', 'custom-fields'],
     structural: true,
     events: companiesEvents,
 
@@ -29,6 +30,7 @@ export function createCompaniesModule(migrationsDirectory: string): KelpieModule
           createId: context.createId,
           now: context.now,
         }),
+        customFields: createCustomFieldValues({ db: context.db }),
       })
 
       context.schema(schema, migrationsDirectory)

package/src/modules/companies/repository.ts

@@ -27,6 +27,8 @@ export interface CompanyFilters {
   readonly term?: string | undefined
   /** `?person_id=`, repeatable: companies where any of these people holds a position. */
   readonly personIds?: readonly string[] | undefined
+  /** `?is_own=true` returns only the workspace's own companies; `false` returns everything else. */
+  readonly isOwn?: boolean | undefined
 }
 
 /**
@@ -64,6 +66,7 @@ function conditionsFor(workspaceId: string, filters: CompanyFilters): (SQL | und
     eq(companies.workspaceId, workspaceId),
     filters.term === undefined ? undefined : matchesTerm(filters.term),
     filters.personIds === undefined ? undefined : employsAnyOf(filters.personIds),
+    filters.isOwn === undefined ? undefined : eq(companies.isOwn, filters.isOwn),
   ]
 }
 

package/src/modules/companies/routes.ts

@@ -1,3 +1,4 @@
+import { customFieldsPatchShape } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -5,6 +6,7 @@ import { pageBody, readIdFilter, readJsonBody, readListParameters } from '../../
 import type { Actor } from '../auth/actor.ts'
 import { resolveActorFrom } from '../auth/credentials.ts'
 import type { CredentialDependencies } from '../auth/credentials.ts'
+import { renderCustomFieldsForWire } from '../custom-fields/wire.ts'
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from './schema.ts'
 import type {
   CompaniesService,
@@ -30,6 +32,8 @@ const companyShape = {
   tech_stack: z.array(z.string().min(1)),
   summary: z.string(),
   tags: z.array(z.string().min(1)),
+  is_own: z.boolean(),
+  custom_fields: customFieldsPatchShape,
 }
 
 /**
@@ -51,6 +55,8 @@ export const createBody = z.strictObject({
   tech_stack: companyShape.tech_stack.default([]),
   summary: companyShape.summary.default(''),
   tags: companyShape.tags.default([]),
+  is_own: companyShape.is_own.default(false),
+  custom_fields: companyShape.custom_fields.default({}),
 })
 
 export const updateBody = z.strictObject(companyShape).partial()
@@ -74,6 +80,8 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateCompanyIn
     techStack: body.tech_stack,
     summary: body.summary,
     tags: body.tags,
+    isOwn: body.is_own,
+    customFields: body.custom_fields,
   }
 }
 
@@ -92,6 +100,8 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateCompanyIn
     ...(body.tech_stack === undefined ? {} : { techStack: body.tech_stack }),
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
+    ...(body.is_own === undefined ? {} : { isOwn: body.is_own }),
+    ...(body.custom_fields === undefined ? {} : { customFields: body.custom_fields }),
   }
 }
 
@@ -111,6 +121,8 @@ export function companyResponse(company: CompanyView): Record<string, unknown> {
     tech_stack: company.techStack,
     summary: company.summary,
     tags: company.tags,
+    is_own: company.isOwn,
+    custom_fields: renderCustomFieldsForWire(company.customFields),
     created_at: company.createdAt.toISOString(),
     updated_at: company.updatedAt.toISOString(),
   }
@@ -120,11 +132,19 @@ export function mountCompaniesRoutes(router: Hono, dependencies: CompaniesRoutes
   const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
 
   router.get('/companies', async (context) => {
+    // `?is_own=true|false` narrows to the workspace's own companies (or the
+    // rest). Anything else is treated as absent, so an unknown value never
+    // returns an accidental "everything".
+    const isOwnParam = context.req.query('is_own')
+    const isOwn =
+      isOwnParam === 'true' ? true : isOwnParam === 'false' ? false : undefined
+
     const page = await dependencies.service.list(
       await requireActor(context),
       {
         term: context.req.query('q'),
         personIds: readIdFilter(context, 'person_id'),
+        isOwn,
       },
       readListParameters(context),
     )

package/src/modules/companies/schema.ts

@@ -1,5 +1,6 @@
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
-import { index, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import type { CustomFieldValue } from '@kelpie/schemas'
+import { boolean, index, jsonb, pgTable, text, unique } from 'drizzle-orm/pg-core'
 
 import {
   checkOneOf,
@@ -42,6 +43,15 @@ export const companies = pgTable(
     techStack: text('tech_stack').array().notNull().default([]),
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
+    // "This is us": a workspace marks its own company (or several, e.g. parent
+    // and subsidiary) so downstream views can distinguish self from prospects.
+    // Loose semantics on purpose — zero or many rows may carry it.
+    isOwn: boolean('is_own').notNull().default(false),
+    // Workspace-defined fields, keyed by definition key. See people/schema.ts.
+    customFields: jsonb('custom_fields')
+      .$type<Readonly<Record<string, CustomFieldValue>>>()
+      .notNull()
+      .default({}),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
     searchVector: searchVector((): readonly SearchVectorPart[] => [