@kiipu/cli 0.0.8 → 0.0.10

package/README.md

@@ -1,15 +1,15 @@
 # Kiipu CLI
 
-Publish to Kiipu from your terminal.
+Create Kiipu notes from your terminal.
 
-`@kiipu/cli` is the official command line interface for Kiipu. It is the best place to start if you want to authenticate locally and post directly from the command line.
+`@kiipu/cli` is the official command line interface for Kiipu. It is the best place to start if you want to authenticate locally and note directly from the command line.
 
 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
+- ask questions over your saved notes
+- create notes from the command line
+- delete, restore, or permanently remove notes by id
 - verify local authentication and API access with `kiipu doctor`
 
 If you want Claude Code integration on top of the CLI, use `@kiipu/claude-plugin`.
@@ -28,10 +28,10 @@ npm install -g @kiipu/cli
 kiipu auth login
 ```
 
-2. Publish a post:
+2. Create a note:
 
 ```bash
-kiipu post create "Hello Kiipu"
+kiipu note create "Hello Kiipu"
 ```
 
 3. Confirm local setup:
@@ -40,7 +40,7 @@ kiipu post create "Hello Kiipu"
 kiipu doctor
 ```
 
-4. Ask over your saved posts:
+4. Ask over your saved notes:
 
 ```bash
 kiipu ask "What did I save about the roadmap?"
@@ -51,7 +51,7 @@ kiipu ask "What did I save about the roadmap?"
 ```bash
 kiipu auth login
 kiipu ask "What should I follow up on?"
-kiipu post create "Ship the beta today"
+kiipu note create "Ship the beta today"
 kiipu auth status
 ```
 
@@ -73,21 +73,21 @@ kiipu auth status
 kiipu auth logout
 ```
 
-## Posting
+## Noteing
 
-Create a post:
+Create a note:
 
 ```bash
-kiipu post create "Ship the beta today"
-kiipu post create --content "Ship the beta today"
+kiipu note create "Ship the beta today"
+kiipu note create --content "Ship the beta today"
 ```
 
-Delete, restore, or permanently remove a post by id:
+Delete, restore, or permanently remove a note by id:
 
 ```bash
-kiipu post delete --id post_123
-kiipu post restore --id post_123
-kiipu post purge --id post_123
+kiipu note delete --id note_123
+kiipu note restore --id note_123
+kiipu note purge --id note_123
 ```
 
 ## Ask
@@ -118,10 +118,10 @@ 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
-kiipu post purge --id post_123
+kiipu note create "Hello Kiipu"
+kiipu note delete --id note_123
+kiipu note restore --id note_123
+kiipu note purge --id note_123
 
 kiipu doctor
 kiipu --help
@@ -152,5 +152,5 @@ See the full command reference in the terminal:
 kiipu --help
 kiipu auth --help
 kiipu ask --help
-kiipu post --help
+kiipu note --help
 ```

package/dist/commands/ask.js

@@ -90,12 +90,7 @@ function readQuestion(args) {
     if (explicit) {
         return explicit;
     }
-    return stripKnownFlags(args, [
-        '--question',
-        '--conversation-id',
-        '--top-k',
-        '--source-mode',
-    ])
+    return stripKnownFlags(args, ['--question', '--conversation-id', '--top-k', '--source-mode'])
         .join(' ')
         .trim();
 }

package/dist/commands/auth.js

@@ -1,5 +1,5 @@
 import { saveKiipuConfig } from '../config/config.js';
-import { createAuthState, createLoopbackServer, createPkcePair, getDefaultDeviceName, openBrowser, waitForEnterBeforeOpeningBrowser } from '../lib/browser-auth.js';
+import { createAuthState, createLoopbackServer, createPkcePair, getDefaultDeviceName, openBrowser, waitForEnterBeforeOpeningBrowser, } from '../lib/browser-auth.js';
 import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
 import { logCliEvent } from '../logger/cli-logger.js';
 async function storeAuthenticatedConfig(config, payload) {

package/dist/commands/doctor.js

@@ -14,11 +14,15 @@ export async function runDoctorCommand(config) {
     const checks = [];
     let ok = true;
     const apiBaseUrlConfig = getConfiguredApiBaseUrl();
-    checks.push(config.apiKey ? `OK API key: ${config.keyPrefix ?? 'configured'}` : 'Missing API key. Run `kiipu auth login`.');
+    checks.push(config.apiKey
+        ? `OK API key: ${config.keyPrefix ?? 'configured'}`
+        : 'Missing API key. Run `kiipu auth login`.');
     if (!(config.apiKey || process.env.KIIPU_API_KEY)) {
         ok = false;
     }
-    checks.push(config.apiKey || process.env.KIIPU_API_KEY ? 'OK post API auth: configured' : 'Missing API key for post requests.');
+    checks.push(config.apiKey || process.env.KIIPU_API_KEY
+        ? 'OK note API auth: configured'
+        : 'Missing API key for note requests.');
     checks.push(apiBaseUrlConfig.source === 'env'
         ? `WARN API base URL override: ${config.apiBaseUrl}`
         : `OK API base URL: ${config.apiBaseUrl}`);
@@ -42,7 +46,9 @@ export async function runDoctorCommand(config) {
         if (!authStatus.ok) {
             ok = false;
         }
-        checks.push(authStatus.ok ? `OK API key auth: ${authStatus.data.username}` : `API key auth failed: ${authStatus.error.message}`);
+        checks.push(authStatus.ok
+            ? `OK API key auth: ${authStatus.data.username}`
+            : `API key auth failed: ${authStatus.error.message}`);
     }
     try {
         await access(configPath);

package/dist/commands/help.js

@@ -16,7 +16,7 @@ export function getHelpResult(command) {
                 '  kiipu ask show --id <conversationId>',
                 '',
                 'Description:',
-                '  Ask questions over your Kiipu posts using the same conversation-aware Ask surface as the web app.',
+                '  Ask questions over your Kiipu notes using the same conversation-aware Ask surface as the web app.',
                 '',
                 'Options:',
                 '  --question "<text>"        Question to ask when not using a positional argument',
@@ -36,64 +36,64 @@ export function getHelpResult(command) {
             ]),
         };
     }
-    if (command === 'post') {
+    if (command === 'note') {
         return {
             ok: true,
             message: block([
                 'Kiipu CLI',
                 '',
                 'Usage:',
-                '  kiipu post create --content "<text>"',
-                '  kiipu post create "<text>"',
-                '  kiipu post list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]',
-                '  kiipu post search <query>',
-                '  kiipu post search --query "<query>"',
-                '  kiipu post show --id <postId>',
-                '  kiipu post update --id <postId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]',
-                '  kiipu post star --id <postId>',
-                '  kiipu post pin --id <postId>',
-                '  kiipu post delete --id <postId>',
-                '  kiipu post restore --id <postId>',
-                '  kiipu post purge --id <postId>',
+                '  kiipu note create --content "<text>" [--title "<title>"]',
+                '  kiipu note create "<text>" [--title "<title>"]',
+                '  kiipu note list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]',
+                '  kiipu note search <query>',
+                '  kiipu note search --query "<query>"',
+                '  kiipu note show --id <noteId>',
+                '  kiipu note update --id <noteId> --content "<text>" [--title "<title>"] [--visibility public|private]',
+                '  kiipu note star --id <noteId>',
+                '  kiipu note pin --id <noteId>',
+                '  kiipu note delete --id <noteId>',
+                '  kiipu note restore --id <noteId>',
+                '  kiipu note purge --id <noteId>',
                 '',
                 'Description:',
-                '  Run direct Kiipu post actions from the local CLI.',
+                '  Run direct Kiipu note actions from the local CLI.',
                 '',
                 'Actions:',
-                '  create      Create a new post',
-                '  list        List your published, starred, or deleted posts',
-                '  search      Search your published posts',
-                '  show        Show one post with full metadata',
-                '  update      Update post content and metadata',
-                '  star        Toggle a post star',
-                '  pin         Toggle a post pin',
-                '  delete      Soft-delete an existing post by explicit id',
-                '  restore     Restore a deleted post by explicit id',
-                '  purge       Permanently delete a post by explicit id',
+                '  create      Create a new note',
+                '  list        List your active, starred, or deleted notes',
+                '  search      Search your active notes',
+                '  show        Show one note with full metadata',
+                '  update      Update note content and metadata',
+                '  star        Toggle a note star',
+                '  pin         Toggle a note pin',
+                '  delete      Soft-delete an existing note by explicit id',
+                '  restore     Restore a deleted note by explicit id',
+                '  purge       Permanently delete a note by explicit id',
                 '',
                 'Options:',
-                '  --content "<text>"         Post content for create',
-                '  --id <postId>              Required for show, update, star, pin, delete, restore, and purge',
-                '  --query "<query>"          Search query for post search',
-                '  --tag <tag>                Filter post list results by tag',
+                '  --content "<text>"         Note content for create',
+                '  --id <noteId>              Required for show, update, star, pin, delete, restore, and purge',
+                '  --query "<query>"          Search query for note search',
+                '  --tag <tag>                Filter note list results by tag',
                 '  --sort <field>             One of updatedAt, createdAt, or title',
-                '  --starred                  List only starred posts',
-                '  --deleted                  List only deleted posts',
-                '  --title "<title>"          Optional title for post update',
-                '  --visibility <value>       Optional visibility for post update',
-                '  --tags <a,b,c>             Optional comma-separated tags for post update',
+                '  --starred                  List only starred notes',
+                '  --deleted                  List only deleted notes',
+                '  --title "<title>"          Optional title for note create or update',
+                '  --visibility <value>       Optional visibility for note update',
+                '  Tags are derived from #tag tokens in note content',
                 '',
                 'Examples:',
-                '  kiipu post create "Hello Kiipu"',
-                '  kiipu post list --sort updatedAt',
-                '  kiipu post search "roadmap"',
-                '  kiipu post show --id 123',
-                '  kiipu post update --id 123 --content "Updated text" --tags work,#notes',
-                '  kiipu post star --id 123',
-                '  kiipu post pin --id 123',
-                '  kiipu post create --content "Hello Kiipu"',
-                '  kiipu post delete --id 123',
-                '  kiipu post restore --id 123',
+                '  kiipu note create "Hello Kiipu" --title "Welcome"',
+                '  kiipu note list --sort updatedAt',
+                '  kiipu note search "roadmap"',
+                '  kiipu note show --id 123',
+                '  kiipu note update --id 123 --content "Updated text #work #notes"',
+                '  kiipu note star --id 123',
+                '  kiipu note pin --id 123',
+                '  kiipu note create --content "Hello Kiipu"',
+                '  kiipu note delete --id 123',
+                '  kiipu note restore --id 123',
             ]),
         };
     }
@@ -173,8 +173,8 @@ 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',
+            '  ask                Ask questions over your Kiipu notes and browse Ask conversations',
+            '  note               Create, browse, update, and delete notes 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',
@@ -182,10 +182,10 @@ export function getHelpResult(command) {
             '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"',
-            '  kiipu post delete --id 123',
+            '  kiipu note create "Hello Kiipu"',
+            '  kiipu note list --starred',
+            '  kiipu note search "Hello"',
+            '  kiipu note delete --id 123',
             '  kiipu auth login',
             '  kiipu doctor',
             '  claude --plugin-dir ./packages/claude-plugin',

package/dist/commands/{post.js → note.js}

@@ -1,6 +1,6 @@
-import { formatPostCollection, formatPostDetail } from '../lib/post-formatters.js';
+import { formatNoteCollection, formatNoteDetail } from '../lib/note-formatters.js';
 import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
-import { executePostAction } from '../lib/post-actions.js';
+import { executeNoteAction } from '../lib/note-actions.js';
 import { hasFlag, readFlag } from '../utils/args.js';
 const actions = new Set([
     'create',
@@ -18,21 +18,21 @@ const sortValues = new Set(['updatedAt', 'createdAt', 'title']);
 function usage(action) {
     switch (action) {
         case 'create':
-            return 'Usage: kiipu post create --content "<text>"\n   or: kiipu post create "<text>"';
+            return 'Usage: kiipu note create --content "<text>" [--title "<title>"]\n   or: kiipu note create "<text>" [--title "<title>"]';
         case 'list':
-            return 'Usage: kiipu post list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]';
+            return 'Usage: kiipu note list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]';
         case 'search':
-            return 'Usage: kiipu post search <query>\n   or: kiipu post search --query "<query>"';
+            return 'Usage: kiipu note search <query>\n   or: kiipu note search --query "<query>"';
         case 'show':
-            return 'Usage: kiipu post show --id <postId>';
+            return 'Usage: kiipu note show --id <noteId>';
         case 'update':
-            return 'Usage: kiipu post update --id <postId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]';
+            return 'Usage: kiipu note update --id <noteId> [--content "<text>" [--title "<title>"]] [--visibility public|private]';
         case 'star':
-            return 'Usage: kiipu post star --id <postId>';
+            return 'Usage: kiipu note star --id <noteId>';
         case 'pin':
-            return 'Usage: kiipu post pin --id <postId>';
+            return 'Usage: kiipu note pin --id <noteId>';
         default:
-            return `Usage: kiipu post ${action} --id <postId>`;
+            return `Usage: kiipu note ${action} --id <noteId>`;
     }
 }
 function error(message) {
@@ -81,58 +81,39 @@ function validateSort(sort) {
     }
     return sortValues.has(sort) ? sort : null;
 }
-function parsePostId(args, action) {
-    const postId = readFlag(args, '--id')?.trim();
-    return postId ? postId : error(usage(action));
+function parseNoteId(args, action) {
+    const noteId = readFlag(args, '--id')?.trim();
+    return noteId ? noteId : error(usage(action));
 }
-function parseTags(input) {
-    if (!input) {
-        return undefined;
-    }
-    const unique = new Map();
-    for (const chunk of input.split(',')) {
-        const cleaned = chunk.trim().replace(/^#+/, '').replace(/\s+/g, ' ');
-        if (!cleaned) {
-            continue;
-        }
-        const normalized = cleaned.toLowerCase();
-        if (!unique.has(normalized)) {
-            unique.set(normalized, cleaned);
-        }
-        if (unique.size === 8) {
-            break;
-        }
-    }
-    return Array.from(unique.values());
-}
-function toCliPost(post) {
+function toCliNote(note) {
     return {
-        id: post.id,
-        title: post.title,
-        rawText: post.rawText,
-        finalText: post.finalText,
-        visibility: post.visibility,
-        tags: post.tags,
-        folder: post.folder ?? null,
-        isPinned: post.isPinned,
-        isStarred: post.isStarred,
-        createdAt: post.createdAt,
-        updatedAt: post.updatedAt,
+        id: note.id,
+        title: note.title,
+        rawText: note.rawText,
+        finalText: note.finalText,
+        visibility: note.visibility,
+        tags: note.tags,
+        folder: note.folder ?? null,
+        isPinned: note.isPinned,
+        isStarred: note.isStarred,
+        createdAt: note.createdAt,
+        updatedAt: note.updatedAt,
     };
 }
 async function handleMutationAction(config, action, args) {
     if (action === 'create') {
-        const content = (readFlag(args, '--content') ?? stripKnownFlags(args, ['--content'])[0])?.trim();
+        const content = (readFlag(args, '--content') ?? stripKnownFlags(args, ['--content', '--title'])[0])?.trim();
         if (!content) {
             return error(usage('create'));
         }
-        return executePostAction(config, { action: 'create', content });
+        const title = readFlag(args, '--title')?.trim();
+        return executeNoteAction(config, { action: 'create', content, ...(title ? { title } : {}) });
     }
-    const postId = parsePostId(args, action);
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, action);
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    return executePostAction(config, { action, postId });
+    return executeNoteAction(config, { action, noteId });
 }
 async function handleList(config, args) {
     const { client, error: clientError } = requireUserClient(config);
@@ -149,36 +130,36 @@ async function handleList(config, args) {
         return error(`--starred and --deleted cannot be used together.\n${usage('list')}`);
     }
     const tag = readFlag(args, '--tag');
-    let posts;
+    let notes;
     let responseData;
     if (starred) {
-        const response = await client.listStarredPosts({ tag, sort });
+        const response = await client.listStarredNotes({ tag, sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map((entry) => toCliPost(entry.post));
+        notes = response.data.map((entry) => toCliNote(entry.note));
         responseData = response.data;
     }
     else if (deleted) {
-        const response = await client.listDeletedPosts({ sort });
+        const response = await client.listDeletedNotes({ sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map(toCliPost);
+        notes = response.data.map(toCliNote);
         responseData = response.data;
     }
     else {
-        const response = await client.listPosts({ tag, sort });
+        const response = await client.listNotes({ tag, sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map(toCliPost);
+        notes = response.data.map(toCliNote);
         responseData = response.data;
     }
-    const title = starred ? 'Starred posts' : deleted ? 'Deleted posts' : 'Posts';
+    const title = starred ? 'Starred notes' : deleted ? 'Deleted notes' : 'Notes';
     return {
         ok: true,
-        message: formatPostCollection(title, posts),
+        message: formatNoteCollection(title, notes),
         data: responseData,
     };
 }
@@ -191,13 +172,13 @@ async function handleSearch(config, args) {
     if (!query) {
         return error(usage('search'));
     }
-    const response = await client.searchPosts(query);
+    const response = await client.searchNotes(query);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: formatPostCollection(`Search results for "${query}"`, response.data.map(toCliPost)),
+        message: formatNoteCollection(`Search results for "${query}"`, response.data.map(toCliNote)),
         data: response.data,
     };
 }
@@ -206,17 +187,17 @@ async function handleShow(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'show');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'show');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.getPost(postId);
+    const response = await client.getNote(noteId);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: formatPostDetail(toCliPost(response.data)),
+        message: formatNoteDetail(toCliNote(response.data)),
         data: response.data,
     };
 }
@@ -225,33 +206,53 @@ async function handleUpdate(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'update');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'update');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
     const content = readFlag(args, '--content')?.trim();
-    if (!content) {
-        return error(usage('update'));
-    }
     const visibility = readFlag(args, '--visibility');
     if (visibility && visibility !== 'public' && visibility !== 'private') {
         return error(`Invalid --visibility value. ${usage('update')}`);
     }
     const title = readFlag(args, '--title');
     const tags = readFlag(args, '--tags');
-    const response = await client.updatePost(postId, {
-        rawText: content,
-        ...(title !== undefined ? { title: title || null } : {}),
-        ...(visibility === 'public' || visibility === 'private' ? { visibility } : {}),
-        ...(tags ? { tags: parseTags(tags) } : {}),
-    });
-    if (!response.ok) {
-        return error(response.error.message);
+    if (tags !== undefined) {
+        return error('Tags are now derived from note content. Add #tag directly in --content.');
+    }
+    if (!content && title !== undefined) {
+        return error(`--title requires --content. ${usage('update')}`);
+    }
+    if (!content && !visibility) {
+        return error(usage('update'));
+    }
+    let updatedNote;
+    if (content) {
+        const response = await client.updateNote(noteId, {
+            rawText: content,
+            ...(title !== undefined ? { title: title || null } : {}),
+        });
+        if (!response.ok) {
+            return error(response.error.message);
+        }
+        updatedNote = response.data;
+    }
+    if (visibility === 'public' || visibility === 'private') {
+        const response = await client.updateNoteMetadata(noteId, {
+            visibility,
+        });
+        if (!response.ok) {
+            return error(response.error.message);
+        }
+        updatedNote = response.data;
+    }
+    if (!updatedNote) {
+        return error(usage('update'));
     }
     return {
         ok: true,
-        message: `Post updated.\n\n${formatPostDetail(toCliPost(response.data))}`,
-        data: response.data,
+        message: `Note updated.\n\n${formatNoteDetail(toCliNote(updatedNote))}`,
+        data: updatedNote,
     };
 }
 async function handleStar(config, args) {
@@ -259,17 +260,19 @@ async function handleStar(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'star');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'star');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.toggleStar(postId);
+    const response = await client.toggleStar(noteId);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: response.data.isStarred ? `Post starred. ${response.data.id}` : `Post unstarred. ${response.data.id}`,
+        message: response.data.isStarred
+            ? `Note starred. ${response.data.id}`
+            : `Note unstarred. ${response.data.id}`,
         data: response.data,
     };
 }
@@ -278,24 +281,26 @@ async function handlePin(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'pin');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'pin');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.togglePin(postId);
+    const response = await client.togglePin(noteId);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: response.data.isPinned ? `Post pinned. ${response.data.id}` : `Post unpinned. ${response.data.id}`,
+        message: response.data.isPinned
+            ? `Note pinned. ${response.data.id}`
+            : `Note unpinned. ${response.data.id}`,
         data: response.data,
     };
 }
-export async function runPostCommand(config, args) {
+export async function runNoteCommand(config, args) {
     const action = args[1];
     if (!action || !actions.has(action)) {
-        return error('Usage: kiipu post <create|delete|restore|purge|list|search|show|update|star|pin> [options]');
+        return error('Usage: kiipu note <create|delete|restore|purge|list|search|show|update|star|pin> [options]');
     }
     const actionArgs = args.slice(2);
     switch (action) {
@@ -317,5 +322,5 @@ export async function runPostCommand(config, args) {
         case 'pin':
             return handlePin(config, actionArgs);
     }
-    return error('Unsupported post action.');
+    return error('Unsupported note action.');
 }

package/dist/config/load-env.js

@@ -13,7 +13,10 @@ function parseEnvFile(content) {
         if (!key || process.env[key] !== undefined) {
             continue;
         }
-        const value = line.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+        const value = line
+            .slice(separatorIndex + 1)
+            .trim()
+            .replace(/^['"]|['"]$/g, '');
         process.env[key] = value;
     }
 }

package/dist/index.js

@@ -5,7 +5,7 @@ import { runAskCommand } from './commands/ask.js';
 import { runAuthCommand } from './commands/auth.js';
 import { runDoctorCommand } from './commands/doctor.js';
 import { getHelpResult } from './commands/help.js';
-import { runPostCommand } from './commands/post.js';
+import { runNoteCommand } from './commands/note.js';
 import { runSkillsCommand } from './commands/skills.js';
 import { readFlag, hasFlag } from './utils/args.js';
 import { CLI_VERSION } from './version.js';
@@ -86,8 +86,8 @@ async function main() {
         result = await runDoctorCommand(await loadKiipuConfig());
         return printResult(result, asJson);
     }
-    if (command === 'post') {
-        result = await runPostCommand(config, commandArgs);
+    if (command === 'note') {
+        result = await runNoteCommand(config, commandArgs);
         return printResult(result, asJson);
     }
     if (command === 'ask') {

package/dist/lib/ask-client.js

@@ -45,14 +45,14 @@ function parseSource(input) {
     if (!isRecord(input)) {
         return null;
     }
-    const postId = typeof input.postId === 'string' ? input.postId : '';
+    const noteId = typeof input.noteId === 'string' ? input.noteId : '';
     const snippet = typeof input.snippet === 'string' ? input.snippet : '';
-    if (!postId || !snippet) {
+    if (!noteId || !snippet) {
         return null;
     }
     return {
         index: typeof input.index === 'number' ? input.index : 0,
-        postId,
+        noteId,
         title: typeof input.title === 'string' ? input.title : null,
         snippet,
         score: typeof input.score === 'number' ? input.score : 0,
@@ -60,7 +60,9 @@ function parseSource(input) {
     };
 }
 function parseSources(input) {
-    return Array.isArray(input) ? input.map(parseSource).filter((source) => Boolean(source)) : [];
+    return Array.isArray(input)
+        ? input.map(parseSource).filter((source) => Boolean(source))
+        : [];
 }
 function parseAskEvent(input) {
     if (!isRecord(input) || typeof input.type !== 'string') {

package/dist/lib/ask-formatters.js

@@ -24,7 +24,7 @@ function truncate(value, maxLength) {
 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}`;
+    return `[${source.index}] ${title} (${source.noteId})${score}`;
 }
 export function formatAskFooter(input) {
     const lines = ['', 'Sources:'];

package/dist/lib/kiipu-integration-client.js

@@ -9,40 +9,46 @@ function buildError(requestId, message, code = 'request_failed') {
         },
     };
 }
-function parseCreatePostRequest(input) {
+function parseCreateNoteRequest(input) {
     const requestId = typeof input.requestId === 'string' ? input.requestId : randomUUID();
     const rawText = typeof input.rawText === 'string' ? input.rawText.trim() : '';
     if (!rawText) {
         throw new Error('rawText is required.');
     }
     const visibility = input.visibility;
-    const tags = Array.isArray(input.tags) ? input.tags.filter((tag) => typeof tag === 'string') : [];
+    const tags = Array.isArray(input.tags)
+        ? input.tags.filter((tag) => typeof tag === 'string')
+        : [];
     return {
         requestId,
         requestedAt: typeof input.requestedAt === 'string' ? input.requestedAt : undefined,
         traceId: typeof input.traceId === 'string' ? input.traceId : undefined,
         rawText,
-        sourceType: input.sourceType === 'manual' || input.sourceType === 'imported' || input.sourceType === 'skill_command'
+        sourceType: input.sourceType === 'manual' ||
+            input.sourceType === 'imported' ||
+            input.sourceType === 'skill_command'
             ? input.sourceType
             : 'skill_command',
         finalText: typeof input.finalText === 'string' ? input.finalText : undefined,
-        visibility: visibility === 'unlisted' || visibility === 'private' || visibility === 'public' ? visibility : 'public',
+        visibility: visibility === 'unlisted' || visibility === 'private' || visibility === 'public'
+            ? visibility
+            : 'public',
         sourceMessageId: typeof input.sourceMessageId === 'string' ? input.sourceMessageId : undefined,
         title: typeof input.title === 'string' ? input.title : input.title === null ? null : undefined,
         tags,
     };
 }
-function parsePostMutationRequest(input) {
+function parseNoteMutationRequest(input) {
     const requestId = typeof input.requestId === 'string' ? input.requestId : randomUUID();
-    const postId = typeof input.postId === 'string' ? input.postId.trim() : '';
-    if (!postId) {
-        throw new Error('postId is required.');
+    const noteId = typeof input.noteId === 'string' ? input.noteId.trim() : '';
+    if (!noteId) {
+        throw new Error('noteId is required.');
     }
     return {
         requestId,
         requestedAt: typeof input.requestedAt === 'string' ? input.requestedAt : undefined,
         traceId: typeof input.traceId === 'string' ? input.traceId : undefined,
-        postId,
+        noteId,
     };
 }
 export class KiipuIntegrationApiClient {
@@ -87,19 +93,19 @@ export class KiipuIntegrationApiClient {
                     ? payload.code
                     : 'request_failed');
     }
-    createPost(input) {
-        return this.request('/integrations/posts', 'POST', parseCreatePostRequest(input));
+    createNote(input) {
+        return this.request('/integrations/notes', 'POST', parseCreateNoteRequest(input));
     }
-    deletePost(input) {
-        const body = parsePostMutationRequest(input);
-        return this.request(`/integrations/posts/${body.postId}/delete`, 'POST', body);
+    deleteNote(input) {
+        const body = parseNoteMutationRequest(input);
+        return this.request(`/integrations/notes/${body.noteId}/delete`, 'POST', body);
     }
-    restorePost(input) {
-        const body = parsePostMutationRequest(input);
-        return this.request(`/integrations/posts/${body.postId}/restore`, 'POST', body);
+    restoreNote(input) {
+        const body = parseNoteMutationRequest(input);
+        return this.request(`/integrations/notes/${body.noteId}/restore`, 'POST', body);
     }
-    permanentDeletePost(input) {
-        const body = parsePostMutationRequest(input);
-        return this.request(`/integrations/posts/${body.postId}/permanent-delete`, 'POST', body);
+    permanentDeleteNote(input) {
+        const body = parseNoteMutationRequest(input);
+        return this.request(`/integrations/notes/${body.noteId}/permanent-delete`, 'POST', body);
     }
 }

package/dist/lib/kiipu-user-client.js

@@ -72,34 +72,40 @@ export class KiipuUserApiClient {
             body: JSON.stringify(input),
         });
     }
-    listPosts(input) {
-        return this.request(this.buildPath('/posts/me', input));
+    listNotes(input) {
+        return this.request(this.buildPath('/notes/me', input));
     }
-    searchPosts(query) {
-        return this.request(this.buildPath('/posts/me/search', { q: query }));
+    searchNotes(query) {
+        return this.request(this.buildPath('/notes/me/search', { q: query }));
     }
-    listStarredPosts(input) {
-        return this.request(this.buildPath('/posts/me/starred', input));
+    listStarredNotes(input) {
+        return this.request(this.buildPath('/notes/me/starred', input));
     }
-    listDeletedPosts(input) {
-        return this.request(this.buildPath('/posts/me/deleted', input));
+    listDeletedNotes(input) {
+        return this.request(this.buildPath('/notes/me/deleted', input));
     }
-    getPost(id) {
-        return this.request(`/posts/${id}`);
+    getNote(id) {
+        return this.request(`/notes/${id}`);
     }
-    updatePost(id, input) {
-        return this.request(`/posts/${id}/content`, {
+    updateNote(id, input) {
+        return this.request(`/notes/${id}/content`, {
+            method: 'PATCH',
+            body: JSON.stringify(input),
+        });
+    }
+    updateNoteMetadata(id, input) {
+        return this.request(`/notes/${id}/metadata`, {
             method: 'PATCH',
             body: JSON.stringify(input),
         });
     }
     toggleStar(id) {
-        return this.request(`/posts/${id}/star`, {
+        return this.request(`/notes/${id}/star`, {
             method: 'PATCH',
         });
     }
     togglePin(id) {
-        return this.request(`/posts/${id}/pin`, {
+        return this.request(`/notes/${id}/pin`, {
             method: 'PATCH',
         });
     }

package/dist/lib/{post-actions.js → note-actions.js}

@@ -3,7 +3,7 @@ import { KiipuIntegrationApiClient } from './kiipu-integration-client.js';
 function formatRequestFailed(message, code) {
     return `Request failed: ${message} (${code}).`;
 }
-function getPostApiClient(config) {
+function getNoteApiClient(config) {
     const apiKey = config.apiKey ?? process.env.KIIPU_API_KEY ?? '';
     if (!apiKey) {
         return {
@@ -20,21 +20,21 @@ function getPostApiClient(config) {
         }),
     };
 }
-export async function executePostAction(config, input) {
-    const { client, error } = getPostApiClient(config);
+export async function executeNoteAction(config, input) {
+    const { client, error } = getNoteApiClient(config);
     if (!client) {
         return error;
     }
     if (input.action === 'create') {
-        const response = await client.createPost({
+        const response = await client.createNote({
             requestId: randomUUID(),
             requestedAt: new Date().toISOString(),
-            traceId: `${input.traceIdPrefix ?? 'post'}-${Date.now()}`,
+            traceId: `${input.traceIdPrefix ?? 'note'}-${Date.now()}`,
             rawText: input.content,
+            ...(input.title ? { title: input.title } : {}),
             sourceType: 'skill_command',
             sourceMessageId: input.sourceMessageId ?? `local-${Date.now()}`,
             visibility: 'public',
-            tags: ['kiipu'],
         });
         if (!response.ok) {
             return {
@@ -44,18 +44,18 @@ export async function executePostAction(config, input) {
         }
         return {
             ok: true,
-            message: `Post published. Post id ${String(response.data.id)} is now visible in the feed.`,
+            message: `Note created. Note id ${String(response.data.id)} is now visible in the feed.`,
             data: response.data,
             requestId: response.requestId,
-            postId: String(response.data.id),
+            noteId: String(response.data.id),
         };
     }
     if (input.action === 'delete') {
-        const response = await client.deletePost({
+        const response = await client.deleteNote({
             requestId: randomUUID(),
             requestedAt: new Date().toISOString(),
             traceId: `${input.traceIdPrefix ?? 'delete'}-${Date.now()}`,
-            postId: input.postId,
+            noteId: input.noteId,
         });
         if (!response.ok) {
             return {
@@ -65,18 +65,18 @@ export async function executePostAction(config, input) {
         }
         return {
             ok: true,
-            message: 'Post deleted. The current post is no longer visible in the feed.',
+            message: 'Note deleted. The current note is no longer visible in the feed.',
             data: response.data,
             requestId: response.requestId,
-            postId: null,
+            noteId: null,
         };
     }
     if (input.action === 'restore') {
-        const response = await client.restorePost({
+        const response = await client.restoreNote({
             requestId: randomUUID(),
             requestedAt: new Date().toISOString(),
             traceId: `${input.traceIdPrefix ?? 'restore'}-${Date.now()}`,
-            postId: input.postId,
+            noteId: input.noteId,
         });
         if (!response.ok) {
             return {
@@ -86,17 +86,17 @@ export async function executePostAction(config, input) {
         }
         return {
             ok: true,
-            message: `Post restored. Post id ${input.postId} is now back in the feed.`,
+            message: `Note restored. Note id ${input.noteId} is now back in the feed.`,
             data: response.data,
             requestId: response.requestId,
-            postId: input.postId,
+            noteId: input.noteId,
         };
     }
-    const response = await client.permanentDeletePost({
+    const response = await client.permanentDeleteNote({
         requestId: randomUUID(),
         requestedAt: new Date().toISOString(),
         traceId: `${input.traceIdPrefix ?? 'purge'}-${Date.now()}`,
-        postId: input.postId,
+        noteId: input.noteId,
     });
     if (!response.ok) {
         return {
@@ -106,9 +106,9 @@ export async function executePostAction(config, input) {
     }
     return {
         ok: true,
-        message: `Post permanently deleted. Post id ${input.postId} has been removed from the database.`,
+        message: `Note permanently deleted. Note id ${input.noteId} has been removed from the database.`,
         data: response.data,
         requestId: response.requestId,
-        postId: null,
+        noteId: null,
     };
 }

package/dist/lib/{post-formatters.js → note-formatters.js}

@@ -23,52 +23,55 @@ function formatTags(tags, limit) {
         : [];
     return normalized.length > 0 ? normalized.map((tag) => `#${tag}`).join(', ') : 'none';
 }
-function getPostPreview(post) {
-    const content = (post.title?.trim() || post.finalText?.trim() || post.rawText?.trim() || '').replace(/\s+/g, ' ');
+function getNotePreview(note) {
+    const content = (note.title?.trim() ||
+        note.finalText?.trim() ||
+        note.rawText?.trim() ||
+        '').replace(/\s+/g, ' ');
     if (!content) {
         return '(empty)';
     }
     return content.length > 100 ? `${content.slice(0, 97)}...` : content;
 }
-function getStatusFlags(post) {
+function getStatusFlags(note) {
     const flags = [];
-    if (post.isPinned) {
+    if (note.isPinned) {
         flags.push('pinned');
     }
-    if (post.isStarred) {
+    if (note.isStarred) {
         flags.push('starred');
     }
     return flags.length > 0 ? flags.join(', ') : 'none';
 }
-export function formatPostCollection(title, posts) {
+export function formatNoteCollection(title, notes) {
     const lines = [title, ''];
-    if (posts.length === 0) {
-        lines.push('No posts found.');
+    if (notes.length === 0) {
+        lines.push('No notes found.');
         return lines.join('\n');
     }
-    for (const post of posts) {
-        lines.push(`${post.id}  ${formatTimestamp(post.updatedAt ?? post.createdAt)}`);
-        lines.push(`  flags: ${getStatusFlags(post)}  visibility: ${post.visibility}  tags: ${formatTags(post.tags, 3)}`);
-        lines.push(`  ${getPostPreview(post)}`);
+    for (const note of notes) {
+        lines.push(`${note.id}  ${formatTimestamp(note.updatedAt ?? note.createdAt)}`);
+        lines.push(`  flags: ${getStatusFlags(note)}  visibility: ${note.visibility}  tags: ${formatTags(note.tags, 3)}`);
+        lines.push(`  ${getNotePreview(note)}`);
         lines.push('');
     }
     return lines.slice(0, -1).join('\n');
 }
-export function formatPostDetail(post) {
-    const title = post.title?.trim() || '(untitled)';
-    const body = post.finalText?.trim() || post.rawText?.trim() || '(empty)';
+export function formatNoteDetail(note) {
+    const title = note.title?.trim() || '(untitled)';
+    const body = note.finalText?.trim() || note.rawText?.trim() || '(empty)';
     return [
         title,
         '',
         body,
         '',
-        `id: ${post.id}`,
-        `visibility: ${post.visibility}`,
-        `created: ${formatTimestamp(post.createdAt)}`,
-        `updated: ${formatTimestamp(post.updatedAt)}`,
-        `tags: ${formatTags(post.tags)}`,
-        `folder: ${post.folder ? `${post.folder.name} (${post.folder.id})` : 'none'}`,
-        `pinned: ${post.isPinned ? 'yes' : 'no'}`,
-        `starred: ${post.isStarred ? 'yes' : 'no'}`,
+        `id: ${note.id}`,
+        `visibility: ${note.visibility}`,
+        `created: ${formatTimestamp(note.createdAt)}`,
+        `updated: ${formatTimestamp(note.updatedAt)}`,
+        `tags: ${formatTags(note.tags)}`,
+        `folder: ${note.folder ? `${note.folder.name} (${note.folder.id})` : 'none'}`,
+        `pinned: ${note.isPinned ? 'yes' : 'no'}`,
+        `starred: ${note.isStarred ? 'yes' : 'no'}`,
     ].join('\n');
 }

package/package.json

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