@kiipu/cli 0.0.7 → 0.0.8

package/README.md

@@ -7,6 +7,7 @@ Publish to Kiipu from your terminal.
 Use it to:
 
 - sign in on the current device
+- ask questions over your saved posts
 - publish posts from the command line
 - delete, restore, or permanently remove posts by id
 - verify local authentication and API access with `kiipu doctor`
@@ -39,10 +40,17 @@ kiipu post create "Hello Kiipu"
 kiipu doctor
 ```
 
+4. Ask over your saved posts:
+
+```bash
+kiipu ask "What did I save about the roadmap?"
+```
+
 ## Example Workflow
 
 ```bash
 kiipu auth login
+kiipu ask "What should I follow up on?"
 kiipu post create "Ship the beta today"
 kiipu auth status
 ```
@@ -82,6 +90,23 @@ kiipu post restore --id post_123
 kiipu post purge --id post_123
 ```
 
+## Ask
+
+Ask a new question and stream the answer:
+
+```bash
+kiipu ask "What did I save about the roadmap?"
+kiipu ask --question "What should I follow up on?"
+```
+
+Continue a conversation or inspect Ask history:
+
+```bash
+kiipu ask --conversation-id conv_123 "What should I do next?"
+kiipu ask history --limit 10
+kiipu ask show --id conv_123
+```
+
 ## Core Commands
 
 ```bash
@@ -89,6 +114,10 @@ kiipu auth login
 kiipu auth status
 kiipu auth logout
 
+kiipu ask "What did I save about the roadmap?"
+kiipu ask history --limit 10
+kiipu ask show --id conv_123
+
 kiipu post create "Hello Kiipu"
 kiipu post delete --id post_123
 kiipu post restore --id post_123
@@ -122,5 +151,6 @@ See the full command reference in the terminal:
 ```bash
 kiipu --help
 kiipu auth --help
+kiipu ask --help
 kiipu post --help
 ```

package/dist/commands/ask.js

@@ -0,0 +1,234 @@
+import { KiipuAskClient } from '../lib/ask-client.js';
+import { formatAskFooter, formatConversationDetail, formatConversationHistory, } from '../lib/ask-formatters.js';
+import { hasFlag, readFlag } from '../utils/args.js';
+const sourceModes = new Set(['fresh', 'locked']);
+function error(message, data) {
+    return {
+        ok: false,
+        message,
+        ...(data ? { data, json: { ok: false, message, ...data } } : {}),
+    };
+}
+function usage(action) {
+    if (action === 'history') {
+        return 'Usage: kiipu ask history [--query <q>] [--limit <n>] [--archived]';
+    }
+    if (action === 'show') {
+        return 'Usage: kiipu ask show --id <conversationId>';
+    }
+    return [
+        'Usage: kiipu ask "question"',
+        '   or: kiipu ask --question "question"',
+        '   or: kiipu ask --conversation-id <id> "follow-up"',
+    ].join('\n');
+}
+function getAskClient(config) {
+    const apiKey = config.apiKey ?? process.env.KIIPU_API_KEY ?? '';
+    if (!apiKey) {
+        return {
+            error: error('Kiipu API key is missing. Run `kiipu auth login` first.', {
+                code: 'missing_api_key',
+            }),
+        };
+    }
+    return {
+        client: new KiipuAskClient({
+            apiBaseUrl: config.apiBaseUrl,
+            apiKey,
+        }),
+    };
+}
+function stripKnownFlags(args, flagsWithValues) {
+    const positional = [];
+    const flags = new Set(flagsWithValues);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (flags.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+        }
+    }
+    return positional;
+}
+function parseTopK(args) {
+    const raw = readFlag(args, '--top-k');
+    if (!raw) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1 || value > 20) {
+        return null;
+    }
+    return value;
+}
+function parseLimit(args) {
+    const raw = readFlag(args, '--limit');
+    if (!raw) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1 || value > 50) {
+        return null;
+    }
+    return value;
+}
+function parseSourceMode(args) {
+    const value = readFlag(args, '--source-mode');
+    if (!value) {
+        return undefined;
+    }
+    return sourceModes.has(value) ? value : null;
+}
+function readQuestion(args) {
+    const explicit = readFlag(args, '--question')?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    return stripKnownFlags(args, [
+        '--question',
+        '--conversation-id',
+        '--top-k',
+        '--source-mode',
+    ])
+        .join(' ')
+        .trim();
+}
+async function handleHistory(config, args) {
+    const { client, error: clientError } = getAskClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const limit = parseLimit(args);
+    if (limit === null) {
+        return error(`Invalid --limit value. ${usage('history')}`, { code: 'invalid_limit' });
+    }
+    const response = await client.listConversations({
+        query: readFlag(args, '--query'),
+        limit,
+        archived: hasFlag(args, '--archived'),
+    });
+    if (!response.ok) {
+        return error(response.error.message, response.error);
+    }
+    return {
+        ok: true,
+        message: formatConversationHistory(hasFlag(args, '--archived') ? 'Archived Ask conversations' : 'Ask conversations', response.data.items, response.data.nextCursor),
+        data: response.data,
+    };
+}
+async function handleShow(config, args) {
+    const { client, error: clientError } = getAskClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const id = readFlag(args, '--id')?.trim();
+    if (!id) {
+        return error(usage('show'), { code: 'missing_conversation_id' });
+    }
+    const response = await client.getConversation(id);
+    if (!response.ok) {
+        return error(response.error.message, response.error);
+    }
+    return {
+        ok: true,
+        message: formatConversationDetail(response.data),
+        data: response.data,
+    };
+}
+async function handleQuestion(config, args, options) {
+    const { client, error: clientError } = getAskClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const question = readQuestion(args);
+    if (!question) {
+        return error(usage(), { code: 'missing_question' });
+    }
+    const topK = parseTopK(args);
+    if (topK === null) {
+        return error(`Invalid --top-k value. ${usage()}`, { code: 'invalid_top_k' });
+    }
+    const sourceMode = parseSourceMode(args);
+    if (sourceMode === null) {
+        return error('Invalid --source-mode value. Use fresh or locked.', {
+            code: 'invalid_source_mode',
+        });
+    }
+    const result = {
+        answer: '',
+        conversationId: readFlag(args, '--conversation-id')?.trim() || undefined,
+        sources: [],
+    };
+    const targetConversationId = result.conversationId ?? 'new';
+    for await (const event of client.streamMessage({
+        conversationId: targetConversationId,
+        question,
+        topK,
+        sourceMode,
+    })) {
+        switch (event.type) {
+            case 'meta':
+                result.conversationId = event.conversationId;
+                result.title = event.title;
+                break;
+            case 'sources':
+                result.sources = event.sources;
+                break;
+            case 'delta':
+                result.answer += event.text;
+                if (options.stream) {
+                    options.write?.(event.text);
+                }
+                break;
+            case 'done':
+                result.turnId = event.turnId;
+                result.usage = {
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                    latencyMs: event.latencyMs,
+                };
+                break;
+            case 'title':
+                result.conversationId = event.conversationId;
+                result.title = event.title;
+                break;
+            case 'error':
+                return error(event.message, {
+                    code: event.code,
+                    answer: result.answer,
+                    conversationId: result.conversationId,
+                    title: result.title,
+                    turnId: result.turnId,
+                    sources: result.sources,
+                    usage: result.usage,
+                });
+        }
+    }
+    const footer = formatAskFooter(result);
+    return {
+        ok: true,
+        message: options.stream ? footer : `${result.answer}${footer}`,
+        data: result,
+        json: {
+            ok: true,
+            ...result,
+        },
+    };
+}
+export async function runAskCommand(config, args, options = {}) {
+    const action = args[1];
+    const actionArgs = args.slice(2);
+    if (action === 'history') {
+        return handleHistory(config, actionArgs);
+    }
+    if (action === 'show') {
+        return handleShow(config, actionArgs);
+    }
+    return handleQuestion(config, args.slice(1), options);
+}

package/dist/commands/help.js

@@ -2,6 +2,40 @@ function block(lines) {
     return lines.join('\n');
 }
 export function getHelpResult(command) {
+    if (command === 'ask') {
+        return {
+            ok: true,
+            message: block([
+                'Kiipu CLI',
+                '',
+                'Usage:',
+                '  kiipu ask "question"',
+                '  kiipu ask --question "question"',
+                '  kiipu ask --conversation-id <conversationId> "follow-up"',
+                '  kiipu ask history [--query <q>] [--limit <n>] [--archived]',
+                '  kiipu ask show --id <conversationId>',
+                '',
+                'Description:',
+                '  Ask questions over your Kiipu posts using the same conversation-aware Ask surface as the web app.',
+                '',
+                'Options:',
+                '  --question "<text>"        Question to ask when not using a positional argument',
+                '  --conversation-id <id>     Continue an existing Ask conversation',
+                '  --top-k <1-20>             Optional retrieval count for Ask',
+                '  --source-mode <value>      One of fresh or locked',
+                '  --query "<query>"          Filter Ask history rows',
+                '  --limit <1-50>             Limit Ask history rows',
+                '  --archived                 List archived Ask conversations',
+                '  --id <conversationId>      Conversation id for ask show',
+                '',
+                'Examples:',
+                '  kiipu ask "What did I save about the roadmap?"',
+                '  kiipu ask --conversation-id conv_123 "What should I do next?"',
+                '  kiipu ask history --limit 10',
+                '  kiipu ask show --id conv_123',
+            ]),
+        };
+    }
     if (command === 'post') {
         return {
             ok: true,
@@ -139,12 +173,15 @@ export function getHelpResult(command) {
             '  kiipu <command> [options]',
             '',
             'Core commands:',
+            '  ask                Ask questions over your Kiipu posts and browse Ask conversations',
             '  post               Create, browse, update, and delete posts with direct CLI arguments',
             '  auth               Manage local API key authentication',
             '  doctor             Check local setup, API access, and wrapper readiness',
             '  skills             Show where the Claude Code plugin package lives',
             '',
             'Core examples:',
+            '  kiipu ask "What changed in my roadmap notes?"',
+            '  kiipu ask history --limit 10',
             '  kiipu post create "Hello Kiipu"',
             '  kiipu post list --starred',
             '  kiipu post search "Hello"',

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import './config/load-env.js';
 import { createDefaultConfig, loadKiipuConfig } from './config/config.js';
+import { runAskCommand } from './commands/ask.js';
 import { runAuthCommand } from './commands/auth.js';
 import { runDoctorCommand } from './commands/doctor.js';
 import { getHelpResult } from './commands/help.js';
@@ -10,7 +11,7 @@ import { readFlag, hasFlag } from './utils/args.js';
 import { CLI_VERSION } from './version.js';
 function printResult(result, asJson) {
     if (asJson) {
-        console.log(JSON.stringify(result, null, 2));
+        console.log(JSON.stringify(result.json ?? result, null, 2));
     }
     else {
         console.log(result.message);
@@ -44,6 +45,11 @@ async function main() {
         '--title',
         '--visibility',
         '--tags',
+        '--question',
+        '--conversation-id',
+        '--top-k',
+        '--source-mode',
+        '--limit',
     ]);
     const positionalArgs = normalizedArgs.filter((arg, index, all) => {
         if (arg === '--json' ||
@@ -84,6 +90,13 @@ async function main() {
         result = await runPostCommand(config, commandArgs);
         return printResult(result, asJson);
     }
+    if (command === 'ask') {
+        result = await runAskCommand(config, commandArgs, {
+            stream: !asJson,
+            write: (chunk) => process.stdout.write(chunk),
+        });
+        return printResult(result, asJson);
+    }
     if (command === 'auth') {
         const action = subcommand;
         if (!action || !['login', 'status', 'logout'].includes(action)) {

package/dist/lib/ask-client.js

@@ -0,0 +1,276 @@
+import { TextDecoder } from 'node:util';
+function isRecord(input) {
+    return typeof input === 'object' && input !== null;
+}
+function buildError(message, code = 'request_failed') {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function getErrorMessage(payload, fallback) {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.message === 'string') {
+        return payload.message;
+    }
+    if (isRecord(payload.message) && typeof payload.message.message === 'string') {
+        return payload.message.message;
+    }
+    if (isRecord(payload.error) && typeof payload.error.message === 'string') {
+        return payload.error.message;
+    }
+    return fallback;
+}
+function getErrorCode(payload, fallback = 'request_failed') {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.code === 'string') {
+        return payload.code;
+    }
+    if (isRecord(payload.message) && typeof payload.message.code === 'string') {
+        return payload.message.code;
+    }
+    if (isRecord(payload.error) && typeof payload.error.code === 'string') {
+        return payload.error.code;
+    }
+    return fallback;
+}
+function parseSource(input) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    const postId = typeof input.postId === 'string' ? input.postId : '';
+    const snippet = typeof input.snippet === 'string' ? input.snippet : '';
+    if (!postId || !snippet) {
+        return null;
+    }
+    return {
+        index: typeof input.index === 'number' ? input.index : 0,
+        postId,
+        title: typeof input.title === 'string' ? input.title : null,
+        snippet,
+        score: typeof input.score === 'number' ? input.score : 0,
+        createdAt: typeof input.createdAt === 'string' ? input.createdAt : undefined,
+    };
+}
+function parseSources(input) {
+    return Array.isArray(input) ? input.map(parseSource).filter((source) => Boolean(source)) : [];
+}
+function parseAskEvent(input) {
+    if (!isRecord(input) || typeof input.type !== 'string') {
+        return null;
+    }
+    switch (input.type) {
+        case 'meta':
+            if (typeof input.conversationId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'meta',
+                conversationId: input.conversationId,
+                isNew: Boolean(input.isNew),
+                title: typeof input.title === 'string' ? input.title : null,
+            };
+        case 'sources':
+            return {
+                type: 'sources',
+                sources: parseSources(input.sources),
+                locked: Boolean(input.locked),
+                retrievalMode: input.retrievalMode === 'semantic' || input.retrievalMode === 'temporal_list'
+                    ? input.retrievalMode
+                    : undefined,
+                totalCount: typeof input.totalCount === 'number' ? input.totalCount : undefined,
+                truncated: typeof input.truncated === 'boolean' ? input.truncated : undefined,
+            };
+        case 'delta':
+            return typeof input.text === 'string' ? { type: 'delta', text: input.text } : null;
+        case 'done':
+            if (typeof input.turnId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'done',
+                turnId: input.turnId,
+                inputTokens: typeof input.inputTokens === 'number' ? input.inputTokens : 0,
+                outputTokens: typeof input.outputTokens === 'number' ? input.outputTokens : 0,
+                latencyMs: typeof input.latencyMs === 'number' ? input.latencyMs : 0,
+            };
+        case 'title':
+            if (typeof input.conversationId !== 'string' || typeof input.title !== 'string') {
+                return null;
+            }
+            return { type: 'title', conversationId: input.conversationId, title: input.title };
+        case 'error':
+            return {
+                type: 'error',
+                code: typeof input.code === 'string' ? input.code : 'unknown',
+                message: typeof input.message === 'string' ? input.message : 'Unknown Ask error.',
+            };
+        default:
+            return null;
+    }
+}
+function extractDataField(frame) {
+    const dataLines = [];
+    for (const line of frame.split('\n')) {
+        const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+        if (normalized.startsWith('data:')) {
+            dataLines.push(normalized.slice(5).replace(/^ /, ''));
+        }
+    }
+    return dataLines.length > 0 ? dataLines.join('\n') : null;
+}
+async function readJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+export class KiipuAskClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async requestJson(path, init) {
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+                ...init,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    ...(init.headers ?? {}),
+                },
+            });
+        }
+        catch {
+            return buildError(`Kiipu API is unreachable at ${this.config.apiBaseUrl}.`, 'api_unreachable');
+        }
+        const payload = await readJson(response);
+        if (!response.ok) {
+            return buildError(getErrorMessage(payload, `Request failed with ${response.status}.`), getErrorCode(payload, `http_${response.status}`));
+        }
+        const data = isRecord(payload) && 'data' in payload ? payload.data : payload;
+        return {
+            ok: true,
+            data: data,
+        };
+    }
+    listConversations(input) {
+        const search = new URLSearchParams();
+        if (input.query) {
+            search.set('q', input.query);
+        }
+        if (input.limit) {
+            search.set('limit', String(input.limit));
+        }
+        if (input.archived) {
+            search.set('view', 'archived');
+        }
+        const query = search.toString();
+        return this.requestJson(`/ai/conversations${query ? `?${query}` : ''}`, { method: 'GET' });
+    }
+    getConversation(id) {
+        return this.requestJson(`/ai/conversations/${encodeURIComponent(id)}`, {
+            method: 'GET',
+        });
+    }
+    async *streamMessage(input) {
+        const body = {
+            question: input.question,
+            ...(input.topK ? { topK: input.topK } : {}),
+            ...(input.sourceMode ? { sourceMode: input.sourceMode } : {}),
+        };
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}/ai/conversations/${encodeURIComponent(input.conversationId)}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            yield {
+                type: 'error',
+                code: 'network_error',
+                message: error instanceof Error ? error.message : 'Network request failed.',
+            };
+            return;
+        }
+        if (!response.ok || !response.body) {
+            const payload = await readJson(response);
+            yield {
+                type: 'error',
+                code: getErrorCode(payload, `http_${response.status}`),
+                message: getErrorMessage(payload, `Request failed with ${response.status}.`),
+            };
+            return;
+        }
+        let settled = false;
+        const decoder = new TextDecoder();
+        const reader = response.body.getReader();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                let separator = buffer.indexOf('\n\n');
+                while (separator !== -1) {
+                    const frame = buffer.slice(0, separator);
+                    buffer = buffer.slice(separator + 2);
+                    const data = extractDataField(frame);
+                    if (data && data !== '[DONE]') {
+                        try {
+                            const event = parseAskEvent(JSON.parse(data));
+                            if (event) {
+                                if (event.type === 'done' || event.type === 'error') {
+                                    settled = true;
+                                }
+                                yield event;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed SSE frames from intermediaries.
+                        }
+                    }
+                    separator = buffer.indexOf('\n\n');
+                }
+            }
+        }
+        catch (error) {
+            if (!settled) {
+                yield {
+                    type: 'error',
+                    code: 'stream_error',
+                    message: error instanceof Error ? error.message : 'Stream interrupted.',
+                };
+            }
+            return;
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (!settled) {
+            yield {
+                type: 'error',
+                code: 'stream_truncated',
+                message: 'The response ended unexpectedly. Please try again.',
+            };
+        }
+    }
+}

package/dist/lib/ask-formatters.js

@@ -0,0 +1,114 @@
+function formatTimestamp(value) {
+    if (!value) {
+        return 'unknown time';
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return value;
+    }
+    return parsed.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function truncate(value, maxLength) {
+    const normalized = value.trim().replace(/\s+/g, ' ');
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+function formatSourceLine(source) {
+    const title = source.title?.trim() || '(untitled)';
+    const score = Number.isFinite(source.score) ? ` score ${source.score.toFixed(3)}` : '';
+    return `[${source.index}] ${title} (${source.postId})${score}`;
+}
+export function formatAskFooter(input) {
+    const lines = ['', 'Sources:'];
+    if (input.sources.length === 0) {
+        lines.push('  none');
+    }
+    else {
+        for (const source of input.sources) {
+            lines.push(`  ${formatSourceLine(source)}`);
+            lines.push(`    ${truncate(source.snippet, 140)}`);
+        }
+    }
+    const usage = input.usage;
+    if (usage) {
+        lines.push('', `Usage: input ${usage.inputTokens}, output ${usage.outputTokens}, latency ${usage.latencyMs}ms`);
+    }
+    if (input.conversationId) {
+        lines.push(`Conversation: ${input.conversationId}`);
+    }
+    if (input.title) {
+        lines.push(`Title: ${input.title}`);
+    }
+    if (input.turnId) {
+        lines.push(`Turn: ${input.turnId}`);
+    }
+    return lines.join('\n');
+}
+export function formatConversationHistory(title, conversations, nextCursor) {
+    const lines = [title, ''];
+    if (conversations.length === 0) {
+        lines.push('No Ask conversations found.');
+        return lines.join('\n');
+    }
+    for (const item of conversations) {
+        const label = item.title?.trim() || truncate(item.preview, 80) || '(untitled)';
+        const flags = [item.pinnedAt ? 'pinned' : '', item.archivedAt ? 'archived' : '']
+            .filter(Boolean)
+            .join(', ');
+        lines.push(`${item.id}  ${formatTimestamp(item.lastMessageAt)}`);
+        lines.push(`  ${label}`);
+        if (flags) {
+            lines.push(`  flags: ${flags}`);
+        }
+        lines.push('');
+    }
+    if (nextCursor) {
+        lines.push(`Next cursor: ${nextCursor}`);
+    }
+    if (!nextCursor && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+function formatTurn(turn) {
+    const role = turn.role === 'user' ? 'User' : 'Assistant';
+    const lines = [`${role} ${turn.id}  ${formatTimestamp(turn.createdAt)}  status: ${turn.status}`];
+    if (turn.errorCode) {
+        lines.push(`error: ${turn.errorCode}`);
+    }
+    lines.push(turn.content.trim() || '(empty)');
+    if (turn.sources && turn.sources.length > 0) {
+        lines.push('sources:');
+        for (const source of turn.sources) {
+            lines.push(`  ${formatSourceLine(source)}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatConversationDetail(detail) {
+    const lines = [
+        detail.title?.trim() || '(untitled Ask conversation)',
+        '',
+        `id: ${detail.id}`,
+        `created: ${formatTimestamp(detail.createdAt)}`,
+        `updated: ${formatTimestamp(detail.lastMessageAt)}`,
+        '',
+    ];
+    if (detail.turns.length === 0) {
+        lines.push('No turns found.');
+    }
+    else {
+        for (const turn of detail.turns) {
+            lines.push(formatTurn(turn), '');
+        }
+    }
+    return lines.slice(0, -1).join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiipu/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Kiipu CLI for local authentication, doctor checks, and direct post actions.",
   "license": "MIT",
   "type": "module",