@agentic-survey/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 netmonty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @agentic-survey/core
+
+Pure TypeScript service layer for [agentic-survey-mcp](https://github.com/netmonty/agentic-survey-mcp). All the survey logic (create, publish, collect, aggregate) over an injected Supabase client. No MCP, no HTTP, no framework types. Functions return a typed `Result` and never throw.
+
+Most people want [`@agentic-survey/mcp-server`](https://www.npmjs.com/package/@agentic-survey/mcp-server) instead. Use this directly only if you're building your own integration on top of the survey model.
+
+```ts
+import { createDb, createSurvey, getResults } from '@agentic-survey/core';
+
+const db = createDb(supabaseUrl, secretKey);
+const survey = await createSurvey(db, { title: 'NPS' });
+```
+
+[MIT](./LICENSE). Docs and issues on [GitHub](https://github.com/netmonty/agentic-survey-mcp).

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import { type SupabaseClient } from '@supabase/supabase-js';
+/**
+ * The injected database handle. `core` never reads global config — callers
+ * build this from supplied credentials and pass it to every function.
+ */
+export type Db = SupabaseClient;
+/**
+ * Build a Supabase client from a project URL + SECRET key (`sb_secret_…`).
+ * The secret key bypasses RLS; it lives only on the user's machine.
+ */
+export declare function createDb(url: string, secretKey: string): Db;

package/dist/client.js

@@ -0,0 +1,10 @@
+import { createClient } from '@supabase/supabase-js';
+/**
+ * Build a Supabase client from a project URL + SECRET key (`sb_secret_…`).
+ * The secret key bypasses RLS; it lives only on the user's machine.
+ */
+export function createDb(url, secretKey) {
+    return createClient(url, secretKey, {
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createDb, type Db } from './client.js';
+export { ok, err, isErr, fromThrown, type Result, type Ok, type Err, } from './result.js';
+export { buildShareUrl, type LinkConfig } from './sharelink.js';
+export { createSurvey, updateSurvey, publishSurvey, closeSurvey, listSurveys, getSurvey, } from './surveys.js';
+export { addQuestion, updateQuestion, removeQuestion, reorderQuestions, } from './questions.js';
+export { listResponses, type ResponseWithAnswers } from './responses.js';
+export { getResults } from './results.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createDb } from './client.js';
+export { ok, err, isErr, fromThrown, } from './result.js';
+export { buildShareUrl } from './sharelink.js';
+export { createSurvey, updateSurvey, publishSurvey, closeSurvey, listSurveys, getSurvey, } from './surveys.js';
+export { addQuestion, updateQuestion, removeQuestion, reorderQuestions, } from './questions.js';
+export { listResponses } from './responses.js';
+export { getResults } from './results.js';

package/dist/mappers.d.ts

@@ -0,0 +1,5 @@
+import type { Survey, Question, Response, Answer } from '@agentic-survey/schema';
+export declare function toSurvey(row: any): Survey;
+export declare function toQuestion(row: any): Question;
+export declare function toResponse(row: any): Response;
+export declare function toAnswer(row: any): Answer;

package/dist/mappers.js

@@ -0,0 +1,41 @@
+/* DB rows are snake_case; domain types are camelCase. Map at the boundary. */
+export function toSurvey(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        description: row.description ?? null,
+        status: row.status,
+        config: (row.config ?? {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        publishedAt: row.published_at ?? null,
+    };
+}
+export function toQuestion(row) {
+    return {
+        id: row.id,
+        surveyId: row.survey_id,
+        position: row.position,
+        type: row.type,
+        prompt: row.prompt,
+        required: row.required,
+        config: (row.config ?? {}),
+        logic: row.logic ?? null,
+    };
+}
+export function toResponse(row) {
+    return {
+        id: row.id,
+        surveyId: row.survey_id,
+        submittedAt: row.submitted_at,
+        respondentMeta: (row.respondent_meta ?? {}),
+    };
+}
+export function toAnswer(row) {
+    return {
+        id: row.id,
+        responseId: row.response_id,
+        questionId: row.question_id,
+        value: row.value,
+    };
+}

package/dist/questions.d.ts

@@ -0,0 +1,24 @@
+import type { Question, QuestionType, QuestionConfig } from '@agentic-survey/schema';
+import type { Db } from './client.js';
+import { type Result } from './result.js';
+export declare function addQuestion(db: Db, surveyId: string, input: {
+    type: QuestionType;
+    prompt: string;
+    required?: boolean;
+    config?: QuestionConfig;
+    position?: number;
+}): Promise<Result<Question>>;
+export declare function updateQuestion(db: Db, questionId: string, patch: {
+    type?: QuestionType;
+    prompt?: string;
+    required?: boolean;
+    config?: QuestionConfig;
+    position?: number;
+}): Promise<Result<Question>>;
+export declare function removeQuestion(db: Db, questionId: string): Promise<Result<void>>;
+/**
+ * Reorder a survey's questions to match `orderedIds`. Positions become the
+ * index in the array. Done sequentially; there's no unique constraint on
+ * position, so intermediate states are fine.
+ */
+export declare function reorderQuestions(db: Db, surveyId: string, orderedIds: string[]): Promise<Result<void>>;

package/dist/questions.js

@@ -0,0 +1,97 @@
+import { ok, err, fromThrown } from './result.js';
+import { toQuestion } from './mappers.js';
+export async function addQuestion(db, surveyId, input) {
+    try {
+        let position = input.position;
+        if (position === undefined) {
+            // Append: one past the current max position for this survey.
+            const { data, error } = await db
+                .from('questions')
+                .select('position')
+                .eq('survey_id', surveyId)
+                .order('position', { ascending: false })
+                .limit(1);
+            if (error)
+                return err('add_question_failed', error.message);
+            position = data && data.length > 0 ? data[0].position + 1 : 0;
+        }
+        const { data, error } = await db
+            .from('questions')
+            .insert({
+            survey_id: surveyId,
+            type: input.type,
+            prompt: input.prompt,
+            required: input.required ?? false,
+            config: input.config ?? {},
+            position,
+        })
+            .select()
+            .single();
+        if (error)
+            return err('add_question_failed', error.message);
+        return ok(toQuestion(data));
+    }
+    catch (e) {
+        return fromThrown('add_question_failed', e);
+    }
+}
+export async function updateQuestion(db, questionId, patch) {
+    try {
+        const row = {};
+        if (patch.type !== undefined)
+            row.type = patch.type;
+        if (patch.prompt !== undefined)
+            row.prompt = patch.prompt;
+        if (patch.required !== undefined)
+            row.required = patch.required;
+        if (patch.config !== undefined)
+            row.config = patch.config;
+        if (patch.position !== undefined)
+            row.position = patch.position;
+        const { data, error } = await db
+            .from('questions')
+            .update(row)
+            .eq('id', questionId)
+            .select()
+            .single();
+        if (error)
+            return err('update_question_failed', error.message);
+        return ok(toQuestion(data));
+    }
+    catch (e) {
+        return fromThrown('update_question_failed', e);
+    }
+}
+export async function removeQuestion(db, questionId) {
+    try {
+        const { error } = await db.from('questions').delete().eq('id', questionId);
+        if (error)
+            return err('remove_question_failed', error.message);
+        return ok(undefined);
+    }
+    catch (e) {
+        return fromThrown('remove_question_failed', e);
+    }
+}
+/**
+ * Reorder a survey's questions to match `orderedIds`. Positions become the
+ * index in the array. Done sequentially; there's no unique constraint on
+ * position, so intermediate states are fine.
+ */
+export async function reorderQuestions(db, surveyId, orderedIds) {
+    try {
+        for (let i = 0; i < orderedIds.length; i++) {
+            const { error } = await db
+                .from('questions')
+                .update({ position: i })
+                .eq('id', orderedIds[i])
+                .eq('survey_id', surveyId);
+            if (error)
+                return err('reorder_questions_failed', error.message);
+        }
+        return ok(undefined);
+    }
+    catch (e) {
+        return fromThrown('reorder_questions_failed', e);
+    }
+}

package/dist/responses.d.ts

@@ -0,0 +1,23 @@
+import type { AnswerValue } from '@agentic-survey/schema';
+import type { Db } from './client.js';
+import { type Result } from './result.js';
+export interface ResponseWithAnswers {
+    id: string;
+    submittedAt: string;
+    respondentMeta: Record<string, unknown>;
+    answers: {
+        questionId: string;
+        value: AnswerValue;
+    }[];
+}
+/**
+ * Paginated raw responses (with their answers), keyset-ordered by
+ * (submitted_at, id) so the agent can page through everything stably.
+ */
+export declare function listResponses(db: Db, surveyId: string, opts?: {
+    limit?: number;
+    cursor?: string;
+}): Promise<Result<{
+    responses: ResponseWithAnswers[];
+    nextCursor: string | null;
+}>>;

package/dist/responses.js

@@ -0,0 +1,57 @@
+import { ok, err, fromThrown } from './result.js';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+function encodeCursor(c) {
+    return Buffer.from(JSON.stringify(c)).toString('base64url');
+}
+function decodeCursor(s) {
+    try {
+        const parsed = JSON.parse(Buffer.from(s, 'base64url').toString('utf8'));
+        if (typeof parsed?.submittedAt === 'string' && typeof parsed?.id === 'string')
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Paginated raw responses (with their answers), keyset-ordered by
+ * (submitted_at, id) so the agent can page through everything stably.
+ */
+export async function listResponses(db, surveyId, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+    try {
+        let q = db
+            .from('responses')
+            .select('id, submitted_at, respondent_meta, answers(question_id, value)')
+            .eq('survey_id', surveyId)
+            .order('submitted_at', { ascending: true })
+            .order('id', { ascending: true })
+            .limit(limit + 1);
+        if (opts.cursor) {
+            const c = decodeCursor(opts.cursor);
+            if (c) {
+                q = q.or(`submitted_at.gt."${c.submittedAt}",and(submitted_at.eq."${c.submittedAt}",id.gt.${c.id})`);
+            }
+        }
+        const { data, error } = await q;
+        if (error)
+            return err('list_responses_failed', error.message);
+        const rows = data ?? [];
+        const hasMore = rows.length > limit;
+        const page = hasMore ? rows.slice(0, limit) : rows;
+        const responses = page.map((r) => ({
+            id: r.id,
+            submittedAt: r.submitted_at,
+            respondentMeta: r.respondent_meta ?? {},
+            answers: (r.answers ?? []).map((a) => ({ questionId: a.question_id, value: a.value })),
+        }));
+        const last = page[page.length - 1];
+        const nextCursor = hasMore && last ? encodeCursor({ submittedAt: last.submitted_at, id: last.id }) : null;
+        return ok({ responses, nextCursor });
+    }
+    catch (e) {
+        return fromThrown('list_responses_failed', e);
+    }
+}

package/dist/result.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Result type — every service function returns this rather than throwing
+ * across the boundary. The `error` shape matches the brief's typed-error
+ * contract ({ error: { code, message } }).
+ */
+export type Ok<T> = {
+    ok: true;
+    data: T;
+};
+export type Err = {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export type Result<T> = Ok<T> | Err;
+export declare const ok: <T>(data: T) => Ok<T>;
+export declare const err: (code: string, message: string) => Err;
+export declare const isErr: <T>(r: Result<T>) => r is Err;
+/** Wrap an unknown thrown value into a typed Err. */
+export declare function fromThrown(code: string, e: unknown): Err;

package/dist/result.js

@@ -0,0 +1,11 @@
+export const ok = (data) => ({ ok: true, data });
+export const err = (code, message) => ({
+    ok: false,
+    error: { code, message },
+});
+export const isErr = (r) => !r.ok;
+/** Wrap an unknown thrown value into a typed Err. */
+export function fromThrown(code, e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return err(code, message);
+}

package/dist/results.d.ts

@@ -0,0 +1,12 @@
+import type { GetResultsPayload } from '@agentic-survey/schema';
+import type { Db } from './client.js';
+import { type Result } from './result.js';
+/**
+ * Aggregates (over ALL responses) + a page of raw responses. Cheap arithmetic
+ * is done here so the consumer agent doesn't burn tokens on it; text answers
+ * are handed back raw for the agent to theme.
+ */
+export declare function getResults(db: Db, surveyId: string, opts?: {
+    responsesLimit?: number;
+    cursor?: string;
+}): Promise<Result<GetResultsPayload>>;

package/dist/results.js

@@ -0,0 +1,173 @@
+import { ok, err, isErr, fromThrown } from './result.js';
+import { getSurvey } from './surveys.js';
+import { listResponses } from './responses.js';
+const pct = (count, total) => total ? Math.round((count / total) * 1000) / 10 : 0;
+function choiceAggregate(q, values) {
+    const opts = (q.config.options ?? []);
+    const counts = new Map();
+    const labels = new Map();
+    for (const o of opts) {
+        counts.set(o.id, 0);
+        labels.set(o.id, o.label);
+    }
+    let totalAnswered = 0;
+    const bump = (sel) => {
+        counts.set(sel.optionId, (counts.get(sel.optionId) ?? 0) + 1);
+        if (!labels.has(sel.optionId))
+            labels.set(sel.optionId, sel.label);
+    };
+    for (const v of values) {
+        if (v.kind === 'single_choice') {
+            totalAnswered++;
+            bump(v.selection);
+        }
+        else if (v.kind === 'multi_choice') {
+            totalAnswered++;
+            for (const s of v.selections)
+                bump(s);
+        }
+    }
+    const options = [...counts.entries()].map(([optionId, count]) => ({
+        optionId,
+        label: labels.get(optionId) ?? optionId,
+        count,
+        pct: pct(count, totalAnswered),
+    }));
+    return { kind: 'choice', options, totalAnswered };
+}
+function yesNoAggregate(values) {
+    let yes = 0;
+    let no = 0;
+    let total = 0;
+    for (const v of values) {
+        if (v.kind === 'yes_no') {
+            total++;
+            if (v.value)
+                yes++;
+            else
+                no++;
+        }
+    }
+    return {
+        kind: 'choice',
+        totalAnswered: total,
+        options: [
+            { optionId: 'yes', label: 'Yes', count: yes, pct: pct(yes, total) },
+            { optionId: 'no', label: 'No', count: no, pct: pct(no, total) },
+        ],
+    };
+}
+function numericAggregate(values) {
+    const nums = [];
+    for (const v of values)
+        if (v.kind === 'rating' || v.kind === 'number')
+            nums.push(v.value);
+    const totalAnswered = nums.length;
+    if (!totalAnswered) {
+        return { kind: 'numeric', mean: null, median: null, min: null, max: null, distribution: [], totalAnswered: 0 };
+    }
+    const sorted = [...nums].sort((a, b) => a - b);
+    const sum = nums.reduce((a, b) => a + b, 0);
+    const mid = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    const distMap = new Map();
+    for (const n of nums)
+        distMap.set(n, (distMap.get(n) ?? 0) + 1);
+    const distribution = [...distMap.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([bucket, count]) => ({ bucket: String(bucket), count }));
+    return {
+        kind: 'numeric',
+        mean: Math.round((sum / totalAnswered) * 100) / 100,
+        median,
+        min: sorted[0],
+        max: sorted[sorted.length - 1],
+        distribution,
+        totalAnswered,
+    };
+}
+function textAggregate(values) {
+    const responses = [];
+    for (const v of values)
+        if (v.kind === 'short_text' || v.kind === 'long_text')
+            responses.push(v.text);
+    return { kind: 'text', totalAnswered: responses.length, responses };
+}
+function aggregateQuestion(q, values) {
+    switch (q.type) {
+        case 'single_choice':
+        case 'multi_choice':
+            return choiceAggregate(q, values);
+        case 'yes_no':
+            return yesNoAggregate(values);
+        case 'rating':
+        case 'number':
+            return numericAggregate(values);
+        case 'short_text':
+        case 'long_text':
+            return textAggregate(values);
+    }
+}
+/**
+ * Aggregates (over ALL responses) + a page of raw responses. Cheap arithmetic
+ * is done here so the consumer agent doesn't burn tokens on it; text answers
+ * are handed back raw for the agent to theme.
+ */
+export async function getResults(db, surveyId, opts = {}) {
+    try {
+        const sv = await getSurvey(db, surveyId);
+        if (isErr(sv))
+            return sv;
+        const { survey, questions } = sv.data;
+        const { count, error: cErr } = await db
+            .from('responses')
+            .select('id', { count: 'exact', head: true })
+            .eq('survey_id', surveyId);
+        if (cErr)
+            return err('get_results_failed', cErr.message);
+        const responseCount = count ?? 0;
+        // All answers for the survey (joined via the response's survey_id).
+        const { data: ansRows, error: aErr } = await db
+            .from('answers')
+            .select('question_id, value, responses!inner(survey_id)')
+            .eq('responses.survey_id', surveyId);
+        if (aErr)
+            return err('get_results_failed', aErr.message);
+        const byQuestion = new Map();
+        for (const r of (ansRows ?? [])) {
+            const arr = byQuestion.get(r.question_id) ?? [];
+            arr.push(r.value);
+            byQuestion.set(r.question_id, arr);
+        }
+        const page = await listResponses(db, surveyId, {
+            limit: opts.responsesLimit,
+            cursor: opts.cursor,
+        });
+        if (isErr(page))
+            return page;
+        return ok({
+            survey: {
+                id: survey.id,
+                title: survey.title,
+                status: survey.status,
+                questionCount: questions.length,
+                responseCount,
+            },
+            questions: questions.map((q) => ({
+                id: q.id,
+                type: q.type,
+                prompt: q.prompt,
+                aggregate: aggregateQuestion(q, byQuestion.get(q.id) ?? []),
+            })),
+            responses: page.data.responses.map((r) => ({
+                id: r.id,
+                submittedAt: r.submittedAt,
+                answers: r.answers,
+            })),
+            pagination: { nextCursor: page.data.nextCursor },
+        });
+    }
+    catch (e) {
+        return fromThrown('get_results_failed', e);
+    }
+}

package/dist/sharelink.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pure share-link construction. `core` stays free of endpoint/key config by
+ * taking it as an argument. The publishable key is client-safe (RLS-fenced)
+ * and travels with the link — see docs/trust-model.md.
+ */
+export interface LinkConfig {
+    /** Page-service base URL, e.g. https://pages.example.com */
+    pageEndpoint: string;
+    /** The user's Supabase project ref. */
+    projectRef: string;
+    /** The user's client-safe publishable key (sb_publishable_…). */
+    publishableKey: string;
+}
+export declare function buildShareUrl(link: LinkConfig, surveyId: string): string;

package/dist/sharelink.js

@@ -0,0 +1,5 @@
+export function buildShareUrl(link, surveyId) {
+    const base = link.pageEndpoint.replace(/\/+$/, '');
+    const key = encodeURIComponent(link.publishableKey);
+    return `${base}/s/${link.projectRef}/${surveyId}#k=${key}`;
+}

package/dist/surveys.d.ts

@@ -0,0 +1,26 @@
+import type { Survey, SurveyStatus, SurveyConfig, Question } from '@agentic-survey/schema';
+import type { Db } from './client.js';
+import { type Result } from './result.js';
+import { type LinkConfig } from './sharelink.js';
+export declare function createSurvey(db: Db, input: {
+    title: string;
+    description?: string;
+    config?: SurveyConfig;
+}): Promise<Result<Survey>>;
+export declare function updateSurvey(db: Db, id: string, patch: {
+    title?: string;
+    description?: string | null;
+    config?: SurveyConfig;
+}): Promise<Result<Survey>>;
+export declare function publishSurvey(db: Db, id: string, link?: LinkConfig): Promise<Result<{
+    survey: Survey;
+    shareUrl?: string;
+}>>;
+export declare function closeSurvey(db: Db, id: string): Promise<Result<Survey>>;
+export declare function listSurveys(db: Db, opts?: {
+    status?: SurveyStatus;
+}): Promise<Result<Survey[]>>;
+export declare function getSurvey(db: Db, id: string): Promise<Result<{
+    survey: Survey;
+    questions: Question[];
+}>>;

package/dist/surveys.js

@@ -0,0 +1,105 @@
+import { ok, err, fromThrown } from './result.js';
+import { toSurvey, toQuestion } from './mappers.js';
+import { buildShareUrl } from './sharelink.js';
+export async function createSurvey(db, input) {
+    try {
+        const { data, error } = await db
+            .from('surveys')
+            .insert({
+            title: input.title,
+            description: input.description ?? null,
+            config: input.config ?? {},
+        })
+            .select()
+            .single();
+        if (error)
+            return err('create_survey_failed', error.message);
+        return ok(toSurvey(data));
+    }
+    catch (e) {
+        return fromThrown('create_survey_failed', e);
+    }
+}
+export async function updateSurvey(db, id, patch) {
+    try {
+        const row = {};
+        if (patch.title !== undefined)
+            row.title = patch.title;
+        if (patch.description !== undefined)
+            row.description = patch.description;
+        if (patch.config !== undefined)
+            row.config = patch.config;
+        const { data, error } = await db.from('surveys').update(row).eq('id', id).select().single();
+        if (error)
+            return err('update_survey_failed', error.message);
+        return ok(toSurvey(data));
+    }
+    catch (e) {
+        return fromThrown('update_survey_failed', e);
+    }
+}
+export async function publishSurvey(db, id, link) {
+    try {
+        const { data, error } = await db
+            .from('surveys')
+            .update({ status: 'published', published_at: new Date().toISOString() })
+            .eq('id', id)
+            .select()
+            .single();
+        if (error)
+            return err('publish_survey_failed', error.message);
+        const survey = toSurvey(data);
+        return ok({ survey, shareUrl: link ? buildShareUrl(link, survey.id) : undefined });
+    }
+    catch (e) {
+        return fromThrown('publish_survey_failed', e);
+    }
+}
+export async function closeSurvey(db, id) {
+    try {
+        const { data, error } = await db
+            .from('surveys')
+            .update({ status: 'closed' })
+            .eq('id', id)
+            .select()
+            .single();
+        if (error)
+            return err('close_survey_failed', error.message);
+        return ok(toSurvey(data));
+    }
+    catch (e) {
+        return fromThrown('close_survey_failed', e);
+    }
+}
+export async function listSurveys(db, opts = {}) {
+    try {
+        let q = db.from('surveys').select().order('created_at', { ascending: false });
+        if (opts.status)
+            q = q.eq('status', opts.status);
+        const { data, error } = await q;
+        if (error)
+            return err('list_surveys_failed', error.message);
+        return ok((data ?? []).map(toSurvey));
+    }
+    catch (e) {
+        return fromThrown('list_surveys_failed', e);
+    }
+}
+export async function getSurvey(db, id) {
+    try {
+        const { data: sRow, error: sErr } = await db.from('surveys').select().eq('id', id).single();
+        if (sErr)
+            return err('get_survey_failed', sErr.message);
+        const { data: qRows, error: qErr } = await db
+            .from('questions')
+            .select()
+            .eq('survey_id', id)
+            .order('position', { ascending: true });
+        if (qErr)
+            return err('get_survey_failed', qErr.message);
+        return ok({ survey: toSurvey(sRow), questions: (qRows ?? []).map(toQuestion) });
+    }
+    catch (e) {
+        return fromThrown('get_survey_failed', e);
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@agentic-survey/core",
+  "version": "0.1.0",
+  "description": "Pure TypeScript service layer for survey logic. No MCP, no HTTP, no framework types.",
+  "license": "MIT",
+  "author": "Monty Daley <monty@daley.org.nz>",
+  "homepage": "https://www.mcpsurveys.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netmonty/agentic-survey-mcp.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/netmonty/agentic-survey-mcp/issues",
+  "keywords": [
+    "survey",
+    "supabase",
+    "mcp",
+    "forms",
+    "service-layer"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --import tsx --env-file-if-exists=../../.env --test src/**/*.test.ts",
+    "prepublishOnly": "tsc -b"
+  },
+  "dependencies": {
+    "@agentic-survey/schema": "^0.1.0",
+    "@supabase/supabase-js": "^2.45.0"
+  }
+}