@crouton-kit/humanloop 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import { Command, Option } from 'commander';
+import { writeFileSync } from 'fs';
+import { launchTui } from './tui/app.js';
+import { dispatchToTmuxPane } from './tui/tmux.js';
+import { findRecentSessionId } from './conversation/reader.js';
+const program = new Command();
+program
+    .name('hl')
+    .description('Human-in-the-loop decision TUI.\n' +
+    '\n' +
+    'Use this when you (the agent) need the human to validate decisions, choose\n' +
+    'between options, or provide freetext input before you continue. The tool\n' +
+    'blocks until the human finishes review and returns their answers as JSON.\n' +
+    '\n' +
+    'Workflow:\n' +
+    '  1. Write a decisions file matching `hl schema` (a JSON list of questions).\n' +
+    '  2. Run `hl create <file>`; it blocks and prints DecisionsOutput JSON to stdout.\n' +
+    '  3. Parse the JSON; each answer\'s `type` mirrors the question\'s `type`.\n' +
+    '\n' +
+    'Question types: validation (approve/reject a statement), choice (pick an\n' +
+    'option or enter custom), freetext (open-ended response).')
+    .version('0.1.0')
+    .addHelpText('after', '\nExamples:\n' +
+    '  hl schema                          # print the input JSON schema\n' +
+    '  hl create decisions.json           # open TUI, block, print answers JSON\n' +
+    '  hl create decisions.json --output answers.json   # write result to file\n' +
+    '  hl create decisions.json --no-tmux # run in current pane even inside tmux\n');
+program
+    .command('create')
+    .description('Open the decisions TUI on <file> and block until the human finishes review.\n' +
+    'Prints DecisionsOutput JSON to stdout (or to --output / --write-to).')
+    .argument('<file>', 'Path to decisions JSON file (see `hl schema` for format)')
+    .option('--session-id <id>', 'Claude session ID; enables per-question visual context from conversation history. Defaults to the most recent session in cwd.')
+    .option('--no-visuals', 'Skip visual context generation (faster, no haiku calls)')
+    .option('--output <path>', 'Write result JSON to <path> instead of stdout')
+    .option('--no-tmux', 'Do not auto-dispatch the TUI to a new tmux pane even when $TMUX is set')
+    .addOption(new Option('--write-to <path>', 'internal: tmux child mode').hideHelp())
+    .addHelpText('after', '\n' +
+    'INPUT FORMAT\n' +
+    '  JSON file with a `questions` array. Each question has an `id`, a `type`\n' +
+    '  ("validation" | "choice" | "freetext"), and `rationale`. Run `hl schema`\n' +
+    '  for the full schema. Example:\n' +
+    '    {\n' +
+    '      "questions": [\n' +
+    '        {"id": "q1", "type": "validation",\n' +
+    '         "statement": "We should use Postgres over SQLite",\n' +
+    '         "rationale": "Need concurrent writes from multiple services"},\n' +
+    '        {"id": "q2", "type": "choice",\n' +
+    '         "question": "Which migration tool?",\n' +
+    '         "rationale": "Need repeatable schema changes",\n' +
+    '         "options": ["Prisma", "Drizzle", "raw SQL"]},\n' +
+    '        {"id": "q3", "type": "freetext",\n' +
+    '         "question": "What should the retry policy be?",\n' +
+    '         "rationale": "Affects reliability budget"}\n' +
+    '      ]\n' +
+    '    }\n' +
+    '\n' +
+    'OUTPUT FORMAT (stdout on success, JSON)\n' +
+    '  {\n' +
+    '    "answers": [ ... ],                      # same order as input questions\n' +
+    '    "completedAt": "2026-04-20T15:23:00.000Z"\n' +
+    '  }\n' +
+    '\n' +
+    '  Answer shape by `type`:\n' +
+    '    validation: { id, type: "validation", approved: boolean, comment?: string }\n' +
+    '    choice:     { id, type: "choice", selected: string, isCustom: boolean, comment?: string }\n' +
+    '    freetext:   { id, type: "freetext", response: string }\n' +
+    '\n' +
+    '  The human can skip questions. `answers` may have FEWER entries than input\n' +
+    '  questions — look up by `id`, do not assume index alignment.\n' +
+    '\n' +
+    'BEHAVIOR\n' +
+    '  tmux       When $TMUX is set, the TUI auto-splits into a new pane to the\n' +
+    '             right (-d keeps focus on the caller). Disable with --no-tmux.\n' +
+    '  progress   Answers are persisted atomically to <file>.progress.json after\n' +
+    '             every change. If the process is killed, the next run resumes\n' +
+    '             from where the human left off. The file is removed on full\n' +
+    '             completion; partial-answer files are preserved.\n' +
+    '  visuals    With --session-id (or auto-detected) haiku generates a short\n' +
+    '             ANSI context block per question from recent conversation turns.\n' +
+    '\n' +
+    'EXIT CODES\n' +
+    '  0  success — result JSON emitted\n' +
+    '  1  error — message on stderr (file missing, invalid JSON, empty\n' +
+    '     questions, no TTY, etc.)\n' +
+    '\n' +
+    'EXAMPLES\n' +
+    '  # Typical agent flow:\n' +
+    '  cat > /tmp/d.json <<EOF\n' +
+    '  {"questions":[{"id":"x","type":"validation",\n' +
+    '   "statement":"...","rationale":"..."}]}\n' +
+    '  EOF\n' +
+    '  hl create /tmp/d.json > /tmp/answers.json\n' +
+    '  jq \'.answers[] | select(.id=="x")\' /tmp/answers.json\n')
+    .action(async (file, opts) => {
+    const sessionId = opts.visuals
+        ? (opts.sessionId || findRecentSessionId(process.cwd()) || findRecentSessionId() || undefined)
+        : undefined;
+    const emit = (result) => {
+        const json = JSON.stringify(result, null, 2) + '\n';
+        if (opts.writeTo) {
+            writeFileSync(opts.writeTo, json);
+        }
+        else if (opts.output) {
+            writeFileSync(opts.output, json);
+        }
+        else {
+            process.stdout.write(json);
+        }
+    };
+    try {
+        if (process.env.TMUX && opts.tmux && !opts.writeTo) {
+            try {
+                const result = await dispatchToTmuxPane(file, { sessionId, visuals: opts.visuals });
+                emit(result);
+                process.exit(0);
+            }
+            catch (err) {
+                process.stderr.write(`tmux dispatch failed, running locally: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+        const result = await launchTui(file, sessionId);
+        emit(result);
+        process.exit(0);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`ERROR: ${msg}\n`);
+        if (msg.includes('not found')) {
+            process.stderr.write('\nFix: pass a path to an existing decisions JSON file.\nSee format: hl schema\n');
+        }
+        else if (msg.includes('No questions')) {
+            process.stderr.write('\nFix: the file must contain a non-empty `questions` array.\nSee format: hl schema\n');
+        }
+        else if (msg.includes('TTY')) {
+            process.stderr.write('\nFix: hl needs an interactive terminal. If the caller captures stdin,\nrun inside tmux so hl can auto-dispatch the TUI to a new pane, or pipe\nstdin from /dev/tty.\n');
+        }
+        else if (msg.includes('JSON')) {
+            process.stderr.write('\nFix: the decisions file must be valid JSON matching `hl schema`.\n');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('schema')
+    .description('Print the decisions-input JSON schema to stdout')
+    .addHelpText('after', '\n' +
+    'Use this to learn the exact input format for `hl create`.\n' +
+    'The schema documents the three question types and their required fields.\n' +
+    '\n' +
+    'Example:\n' +
+    '  hl schema > decisions.schema.json  # save for reference\n' +
+    '  hl schema | jq                     # pretty-print\n')
+    .action(() => {
+    const schema = {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        description: 'Input schema for hl create',
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                description: 'Optional title shown in the TUI header',
+            },
+            questions: {
+                type: 'array',
+                items: {
+                    oneOf: [
+                        {
+                            type: 'object',
+                            description: 'Validation — a statement for the user to approve or reject (with optional comment)',
+                            required: ['id', 'type', 'statement', 'rationale'],
+                            properties: {
+                                id: { type: 'string' },
+                                type: { const: 'validation' },
+                                statement: { type: 'string', description: 'A statement to validate, not a question' },
+                                rationale: { type: 'string', description: 'Why this decision was made' },
+                            },
+                        },
+                        {
+                            type: 'object',
+                            description: 'Choice — pick from options or provide a custom answer',
+                            required: ['id', 'type', 'question', 'rationale', 'options'],
+                            properties: {
+                                id: { type: 'string' },
+                                type: { const: 'choice' },
+                                question: { type: 'string' },
+                                rationale: { type: 'string' },
+                                options: { type: 'array', items: { type: 'string' }, minItems: 2 },
+                            },
+                        },
+                        {
+                            type: 'object',
+                            description: 'Freetext — open-ended response',
+                            required: ['id', 'type', 'question', 'rationale'],
+                            properties: {
+                                id: { type: 'string' },
+                                type: { const: 'freetext' },
+                                question: { type: 'string' },
+                                rationale: { type: 'string' },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        required: ['questions'],
+    };
+    process.stdout.write(JSON.stringify(schema, null, 2) + '\n');
+});
+program.parse();

package/dist/conversation/reader.d.ts

@@ -0,0 +1,6 @@
+export interface ConversationMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export declare function readConversation(sessionId: string): ConversationMessage[];
+export declare function findRecentSessionId(cwd?: string): string | null;

package/dist/conversation/reader.js

@@ -0,0 +1,58 @@
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+const CLAUDE_DB_PATH = join(homedir(), '.claude', '__store.db');
+export function readConversation(sessionId) {
+    if (!existsSync(CLAUDE_DB_PATH)) {
+        throw new Error(`Claude database not found at ${CLAUDE_DB_PATH}`);
+    }
+    const query = `
+    SELECT bm.message_type,
+           COALESCE(um.message, am.message) AS content
+    FROM base_messages bm
+    LEFT JOIN user_messages um ON bm.uuid = um.uuid
+    LEFT JOIN assistant_messages am ON bm.uuid = am.uuid
+    WHERE bm.session_id = '${sessionId.replace(/'/g, "''")}'
+    ORDER BY bm.timestamp ASC;
+  `;
+    const raw = execSync(`sqlite3 -json "${CLAUDE_DB_PATH}" "${query.replace(/"/g, '\\"')}"`, {
+        encoding: 'utf8',
+        maxBuffer: 50 * 1024 * 1024,
+    });
+    if (!raw.trim())
+        return [];
+    const rows = JSON.parse(raw);
+    const messages = [];
+    for (const row of rows) {
+        if (!row.content)
+            continue;
+        if (row.message_type === 'user' || row.message_type === 'assistant') {
+            messages.push({
+                role: row.message_type,
+                content: row.content,
+            });
+        }
+    }
+    return messages;
+}
+export function findRecentSessionId(cwd) {
+    if (!existsSync(CLAUDE_DB_PATH))
+        return null;
+    const whereClause = cwd
+        ? `WHERE cwd = '${cwd.replace(/'/g, "''")}'`
+        : '';
+    const query = `SELECT DISTINCT session_id FROM base_messages ${whereClause} ORDER BY timestamp DESC LIMIT 1;`;
+    try {
+        const raw = execSync(`sqlite3 -json "${CLAUDE_DB_PATH}" "${query.replace(/"/g, '\\"')}"`, {
+            encoding: 'utf8',
+        });
+        if (!raw.trim())
+            return null;
+        const rows = JSON.parse(raw);
+        return rows[0]?.session_id ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,2 @@
+import type { DecisionsOutput } from '../types.js';
+export declare function launchTui(decisionsPath: string, sessionId?: string): Promise<DecisionsOutput>;

package/dist/tui/app.js

@@ -0,0 +1,136 @@
+import { readFileSync, existsSync, writeFileSync, renameSync, unlinkSync } from 'fs';
+import { setupTerminal, restoreTerminal, parseKeypress, getTerminalSize } from './terminal.js';
+import { flush, renderOverview, renderItemReview, renderFinal } from './render.js';
+import { handleKeypress } from './input.js';
+import { readConversation } from '../conversation/reader.js';
+import { generateVisuals } from '../visuals/generate.js';
+export async function launchTui(decisionsPath, sessionId) {
+    if (!existsSync(decisionsPath)) {
+        throw new Error(`Decisions file not found: ${decisionsPath}`);
+    }
+    const raw = readFileSync(decisionsPath, 'utf8');
+    const input = JSON.parse(raw);
+    if (!input.questions || input.questions.length === 0) {
+        throw new Error('No questions in decisions file');
+    }
+    const state = {
+        phase: 'overview',
+        currentIndex: 0,
+        questions: input.questions,
+        answers: new Map(),
+        visuals: new Map(),
+        inputMode: null,
+        selectedAction: 0,
+        detailExpanded: false,
+        scrollOffset: 0,
+    };
+    const progressPath = `${decisionsPath}.progress.json`;
+    state.persist = () => {
+        const answers = [];
+        for (const q of input.questions) {
+            const a = state.answers.get(q.id);
+            if (a)
+                answers.push(a);
+        }
+        const payload = {
+            partial: true,
+            answers,
+            savedAt: new Date().toISOString(),
+        };
+        try {
+            const tmp = `${progressPath}.tmp`;
+            writeFileSync(tmp, JSON.stringify(payload, null, 2));
+            renameSync(tmp, progressPath);
+        }
+        catch {
+            // best-effort — do not crash the TUI if the directory isn't writable
+        }
+    };
+    if (existsSync(progressPath)) {
+        try {
+            const prior = JSON.parse(readFileSync(progressPath, 'utf8'));
+            const validIds = new Set(input.questions.map((q) => q.id));
+            for (const a of prior.answers ?? []) {
+                if (validIds.has(a.id))
+                    state.answers.set(a.id, a);
+            }
+            const firstUnanswered = input.questions.findIndex((q) => !state.answers.has(q.id));
+            state.currentIndex = firstUnanswered >= 0 ? firstUnanswered : 0;
+        }
+        catch {
+            // corrupt progress file — ignore and start fresh
+        }
+    }
+    // Initialize visuals — 'loading' if we'll generate them, skip otherwise
+    if (sessionId) {
+        for (const q of input.questions) {
+            state.visuals.set(q.id, { questionId: q.id, content: '', status: 'loading' });
+        }
+    }
+    setupTerminal();
+    const render = () => {
+        let lines;
+        switch (state.phase) {
+            case 'overview':
+                lines = renderOverview(state);
+                break;
+            case 'item-review':
+                lines = renderItemReview(state);
+                break;
+            case 'final':
+                lines = renderFinal(state);
+                break;
+        }
+        flush(lines);
+    };
+    // Initial render
+    render();
+    // Fan out haiku visual generation in background
+    if (sessionId) {
+        try {
+            const conversation = readConversation(sessionId);
+            if (conversation.length > 0) {
+                const { cols } = getTerminalSize();
+                const visualWidth = Math.max(40, Math.min(cols - 4, 76));
+                generateVisuals(input.questions, conversation, (qId, block) => {
+                    state.visuals.set(qId, block);
+                    render();
+                }, visualWidth).catch((err) => {
+                    process.stderr.write(`Visual generation failed: ${err}\n`);
+                });
+            }
+        }
+        catch (err) {
+            for (const q of input.questions) {
+                state.visuals.set(q.id, { questionId: q.id, content: '', status: 'error' });
+            }
+        }
+    }
+    return new Promise((resolve) => {
+        const exit = () => {
+            restoreTerminal();
+            process.stdin.removeListener('data', onData);
+            const answers = [];
+            for (const q of input.questions) {
+                const a = state.answers.get(q.id);
+                if (a)
+                    answers.push(a);
+            }
+            if (answers.length >= input.questions.length) {
+                try {
+                    unlinkSync(progressPath);
+                }
+                catch { /* ignore */ }
+            }
+            resolve({
+                answers,
+                completedAt: new Date().toISOString(),
+            });
+        };
+        const onData = (data) => {
+            const { input: inp, key } = parseKeypress(data);
+            handleKeypress(inp, key, state, render, exit);
+        };
+        process.stdin.on('data', onData);
+    });
+}

package/dist/tui/input.d.ts

@@ -0,0 +1,5 @@
+import type { TuiState } from '../types.js';
+import type { Key } from './terminal.js';
+export type RenderFn = () => void;
+export type ExitFn = () => void;
+export declare function handleKeypress(input: string, key: Key, state: TuiState, render: RenderFn, exit: ExitFn): void;

package/dist/tui/input.js

@@ -0,0 +1,257 @@
+export function handleKeypress(input, key, state, render, exit) {
+    if (key.ctrl && input === 'c') {
+        exit();
+        return;
+    }
+    if (state.inputMode) {
+        handleInputMode(input, key, state, render);
+        checkAutoExit(state, exit);
+        return;
+    }
+    switch (state.phase) {
+        case 'overview':
+            handleOverview(input, key, state, render, exit);
+            break;
+        case 'item-review':
+            handleItemReview(input, key, state, render);
+            checkAutoExit(state, exit);
+            break;
+        case 'final':
+            handleFinal(input, key, state, render, exit);
+            break;
+    }
+}
+function checkAutoExit(state, exit) {
+    if (state.phase === 'final' && state.answers.size >= state.questions.length) {
+        exit();
+    }
+}
+// ── Overview ─────────────────────────────────────────────────────────────────
+function handleOverview(input, key, state, render, exit) {
+    if (input === 'j' || key.downArrow) {
+        state.currentIndex = Math.min(state.currentIndex + 1, state.questions.length - 1);
+        render();
+    }
+    else if (input === 'k' || key.upArrow) {
+        state.currentIndex = Math.max(state.currentIndex - 1, 0);
+        render();
+    }
+    else if (key.return) {
+        state.phase = 'item-review';
+        state.selectedAction = 0;
+        state.detailExpanded = false;
+        render();
+    }
+    else if (input === 'q') {
+        if (state.answers.size >= state.questions.length) {
+            exit();
+        }
+        else {
+            state.phase = 'final';
+            render();
+        }
+    }
+}
+// ── Item Review ──────────────────────────────────────────────────────────────
+function handleItemReview(input, key, state, render) {
+    const q = state.questions[state.currentIndex];
+    // Navigation
+    if (input === 'n') {
+        advanceItem(state, 1);
+        render();
+        return;
+    }
+    if (input === 'p') {
+        advanceItem(state, -1);
+        render();
+        return;
+    }
+    if (input === 'q') {
+        state.phase = 'overview';
+        render();
+        return;
+    }
+    if (input === ' ') {
+        state.detailExpanded = !state.detailExpanded;
+        render();
+        return;
+    }
+    // Action selection with j/k
+    if (input === 'j' || key.downArrow) {
+        const max = actionCount(q) - 1;
+        state.selectedAction = Math.min(state.selectedAction + 1, max);
+        render();
+        return;
+    }
+    if (input === 'k' || key.upArrow) {
+        state.selectedAction = Math.max(state.selectedAction - 1, 0);
+        render();
+        return;
+    }
+    // Type-specific actions
+    if (q.type === 'validation') {
+        handleValidationAction(input, key, state, q, render);
+    }
+    else if (q.type === 'choice') {
+        handleChoiceAction(input, key, state, q, render);
+    }
+    else {
+        handleFreetextAction(input, key, state, render);
+    }
+}
+function handleValidationAction(input, key, state, q, render) {
+    if (input === '1' || (key.return && state.selectedAction === 0)) {
+        state.answers.set(q.id, { id: q.id, type: 'validation', approved: true });
+        state.persist?.();
+        advanceItem(state, 1);
+        render();
+    }
+    else if (input === '2' || (key.return && state.selectedAction === 1)) {
+        state.inputMode = { kind: 'comment', buffer: '' };
+        state.answers.set(q.id, { id: q.id, type: 'validation', approved: true, comment: '' });
+        state.persist?.();
+        render();
+    }
+    else if (input === '3' || (key.return && state.selectedAction === 2)) {
+        state.answers.set(q.id, { id: q.id, type: 'validation', approved: false });
+        state.persist?.();
+        advanceItem(state, 1);
+        render();
+    }
+    else if (input === '4' || (key.return && state.selectedAction === 3)) {
+        state.inputMode = { kind: 'comment', buffer: '' };
+        state.answers.set(q.id, { id: q.id, type: 'validation', approved: false, comment: '' });
+        state.persist?.();
+        render();
+    }
+}
+function handleChoiceAction(input, key, state, q, render) {
+    const numOptions = q.options.length;
+    const digit = parseInt(input, 10);
+    if (digit >= 1 && digit <= numOptions) {
+        state.answers.set(q.id, {
+            id: q.id,
+            type: 'choice',
+            selected: q.options[digit - 1],
+            isCustom: false,
+        });
+        state.persist?.();
+        advanceItem(state, 1);
+        render();
+        return;
+    }
+    if (digit === numOptions + 1 || (key.return && state.selectedAction === numOptions)) {
+        state.inputMode = { kind: 'custom-option', buffer: '' };
+        render();
+        return;
+    }
+    if (key.return && state.selectedAction < numOptions) {
+        state.answers.set(q.id, {
+            id: q.id,
+            type: 'choice',
+            selected: q.options[state.selectedAction],
+            isCustom: false,
+        });
+        state.persist?.();
+        advanceItem(state, 1);
+        render();
+    }
+}
+function handleFreetextAction(input, key, state, render) {
+    if (input === 'r' || key.return) {
+        const existing = state.answers.get(state.questions[state.currentIndex].id);
+        const prefill = existing?.type === 'freetext' ? existing.response : '';
+        state.inputMode = { kind: 'freetext', buffer: prefill };
+        render();
+    }
+}
+// ── Input Mode ───────────────────────────────────────────────────────────────
+function handleInputMode(input, key, state, render) {
+    const mode = state.inputMode;
+    if (key.escape) {
+        state.inputMode = null;
+        render();
+        return;
+    }
+    if (key.return) {
+        commitInput(state);
+        state.inputMode = null;
+        advanceItem(state, 1);
+        render();
+        return;
+    }
+    if (key.backspace) {
+        mode.buffer = mode.buffer.slice(0, -1);
+        render();
+        return;
+    }
+    if (input.length === 1 && input.charCodeAt(0) >= 32) {
+        mode.buffer += input;
+        render();
+    }
+}
+function commitInput(state) {
+    const q = state.questions[state.currentIndex];
+    const mode = state.inputMode;
+    if (mode.kind === 'comment') {
+        const existing = state.answers.get(q.id);
+        const approved = existing ? existing.approved : false;
+        state.answers.set(q.id, {
+            id: q.id,
+            type: 'validation',
+            approved,
+            comment: mode.buffer || undefined,
+        });
+    }
+    else if (mode.kind === 'custom-option') {
+        if (mode.buffer) {
+            state.answers.set(q.id, {
+                id: q.id,
+                type: 'choice',
+                selected: mode.buffer,
+                isCustom: true,
+            });
+        }
+    }
+    else if (mode.kind === 'freetext') {
+        if (mode.buffer) {
+            state.answers.set(q.id, {
+                id: q.id,
+                type: 'freetext',
+                response: mode.buffer,
+            });
+        }
+    }
+    state.persist?.();
+}
+// ── Final ────────────────────────────────────────────────────────────────────
+function handleFinal(input, key, state, render, exit) {
+    if (key.return) {
+        exit();
+    }
+    else if (input === 'p') {
+        state.phase = 'item-review';
+        state.currentIndex = state.questions.length - 1;
+        render();
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function advanceItem(state, direction) {
+    const next = state.currentIndex + direction;
+    if (next < 0)
+        return;
+    if (next >= state.questions.length) {
+        state.phase = 'final';
+        return;
+    }
+    state.currentIndex = next;
+    state.selectedAction = 0;
+    state.detailExpanded = false;
+}
+function actionCount(q) {
+    switch (q.type) {
+        case 'validation': return 4;
+        case 'choice': return q.options.length + 1;
+        case 'freetext': return 1;
+    }
+}