@jackwener/opencli 1.6.2 → 1.6.4

package/dist/clis/lesswrong/_helpers.js

@@ -0,0 +1,75 @@
+import { CommandExecutionError, EmptyResultError } from '../../src/errors.js';
+export const SITE = 'lesswrong';
+export const DOMAIN = 'www.lesswrong.com';
+const GRAPHQL_URL = `https://${DOMAIN}/graphql`;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- GraphQL responses vary per query
+export async function gqlRequest(query) {
+    const resp = await fetch(GRAPHQL_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify({ query }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) {
+        throw new CommandExecutionError(`LessWrong API returned HTTP ${resp.status}`);
+    }
+    const json = (await resp.json());
+    if (json.errors?.length) {
+        throw new CommandExecutionError(json.errors[0]?.message ?? 'Unknown GraphQL error');
+    }
+    return json.data;
+}
+export function gqlEscape(str) {
+    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export function stripHtml(html) {
+    if (!html)
+        return '';
+    return html
+        .replace(/<script[^>]*>.*?<\/script>/gis, ' ')
+        .replace(/<style[^>]*>.*?<\/style>/gis, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function daysAgo(n) {
+    const d = new Date();
+    d.setDate(d.getDate() - n);
+    return d.toISOString();
+}
+export async function resolveTagId(slug) {
+    const normalized = gqlEscape(slug.toLowerCase().trim().replace(/\s+/g, '-'));
+    const query = `query TagBySlug {
+    tags(input: {terms: {view: "tagBySlug", slug: "${normalized}"}}) {
+      results { _id name slug }
+    }
+  }`;
+    const data = await gqlRequest(query);
+    const tag = data?.tags?.results?.[0];
+    if (!tag?._id || !tag?.name)
+        return null;
+    return { _id: tag._id, name: tag.name };
+}
+export function resolveUserId(slug) {
+    const normalized = gqlEscape(slug.toLowerCase());
+    const query = `query UserProfile {
+    user(input: {selector: {slug: "${normalized}"}}) {
+      result { _id displayName slug }
+    }
+  }`;
+    return gqlRequest(query).then((data) => {
+        const user = data?.user?.result;
+        if (!user?._id) {
+            throw new EmptyResultError(`lesswrong user ${slug}`, 'Check the username — LessWrong slugs are lowercase (e.g. "zvi", "eliezer-yudkowsky")');
+        }
+        return { _id: user._id, displayName: (user.displayName ?? '') };
+    });
+}
+export function parsePostId(urlOrId) {
+    const trimmed = urlOrId.trim();
+    const match = trimmed.match(/posts\/([a-zA-Z0-9]+)/);
+    return match ? match[1] : trimmed;
+}

package/dist/clis/lesswrong/comments.js

@@ -0,0 +1,64 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { EmptyResultError } from '../../src/errors.js';
+import { DOMAIN, SITE, gqlEscape, gqlRequest, parsePostId, stripHtml, } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'comments',
+    description: 'Top comments on a post',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'url-or-id',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'Post URL or LessWrong post ID',
+        },
+        { name: 'limit', type: 'int', default: 5, help: 'Number of comments' },
+    ],
+    columns: ['rank', 'score', 'author', 'text'],
+    func: async (_page, kwargs) => {
+        const postId = gqlEscape(parsePostId(String(kwargs['url-or-id'])));
+        const limit = Number(kwargs.limit ?? 5);
+        // Fetch post title and comments in parallel
+        const [postData, commentsData] = await Promise.all([
+            gqlRequest(`query PostTitle {
+        post(input: {selector: {documentId: "${postId}"}}) {
+          result { _id title slug }
+        }
+      }`),
+            gqlRequest(`query Comments {
+        comments(input: {terms: {view: "postCommentsTop", postId: "${postId}", limit: ${limit}}}) {
+          results { _id user { displayName } baseScore htmlBody postedAt }
+        }
+      }`),
+        ]);
+        const post = postData?.post?.result;
+        if (!post?._id) {
+            throw new EmptyResultError('lesswrong comments', `Post "${postId}" not found`);
+        }
+        const comments = (commentsData?.comments?.results ?? []);
+        const rows = [];
+        // First row: post context
+        rows.push({
+            rank: '',
+            score: '',
+            author: '',
+            text: `Comments on: ${post.title ?? 'Untitled'} (https://${DOMAIN}/posts/${post._id}/${post.slug})`,
+        });
+        for (let i = 0; i < comments.length; i++) {
+            const item = comments[i];
+            const user = item.user;
+            const raw = stripHtml(item.htmlBody ?? '');
+            rows.push({
+                rank: i + 1,
+                score: item.baseScore ?? 0,
+                author: user?.displayName ?? 'Unknown',
+                text: raw.length > 500 ? `${raw.slice(0, 500)}...` : raw,
+            });
+        }
+        return rows;
+    },
+});

package/dist/clis/lesswrong/curated.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'curated',
+    description: "Curated editor's picks",
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "curated", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/frontpage.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'frontpage',
+    description: 'Algorithmic frontpage',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "frontpage", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/new.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'new',
+    description: 'Latest posts',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "new", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/read.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { EmptyResultError } from '../../src/errors.js';
+import { DOMAIN, SITE, gqlEscape, gqlRequest, parsePostId, stripHtml, } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'read',
+    description: 'Read full post by URL or ID',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'url-or-id',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'Post URL or LessWrong post ID',
+        },
+    ],
+    columns: ['title', 'author', 'karma', 'comments', 'tags', 'content', 'url'],
+    func: async (_page, kwargs) => {
+        const postId = parsePostId(String(kwargs['url-or-id']));
+        const query = `query PostsSingle {
+      post(input: {selector: {documentId: "${gqlEscape(postId)}"}}) {
+        result { _id title user { displayName } baseScore commentCount htmlBody slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const post = data?.post?.result;
+        if (!post?._id) {
+            throw new EmptyResultError('lesswrong read', `Post "${postId}" not found`);
+        }
+        return [
+            {
+                title: post.title ?? '',
+                author: post.user?.displayName ?? 'Unknown',
+                karma: post.baseScore ?? 0,
+                comments: post.commentCount ?? 0,
+                tags: (post.tags ?? []).map((tag) => tag.name ?? '').filter(Boolean).join(', '),
+                content: stripHtml(post.htmlBody ?? ''),
+                url: `https://${DOMAIN}/posts/${post._id}/${post.slug}`,
+            },
+        ];
+    },
+});

package/dist/clis/lesswrong/sequences.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'sequences',
+    description: 'List post collections',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query Sequences {
+      sequences(input: {terms: {view: "communitySequences", limit: ${limit}}}) {
+        results { _id title user { displayName } createdAt }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const sequences = (data?.sequences?.results ?? []);
+        return sequences.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+        }));
+    },
+});

package/dist/clis/lesswrong/shortform.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'shortform',
+    description: 'Quick takes / shortform posts',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "shortform", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/tag.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { EmptyResultError } from '../../src/errors.js';
+import { DOMAIN, SITE, gqlRequest, resolveTagId } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'tag',
+    description: 'Posts by tag',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'tag',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'Tag slug or name',
+        },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const tagInput = String(kwargs.tag);
+        const limit = Number(kwargs.limit ?? 10);
+        const tag = await resolveTagId(tagInput);
+        if (!tag?._id) {
+            throw new EmptyResultError(`lesswrong tag ${tagInput}`, 'Use "opencli lesswrong tags" to list available tags');
+        }
+        const query = `query PostsByTag {
+      posts(input: {terms: {view: "tagRelevance", tagId: "${tag._id}", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/tags.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'tags',
+    description: 'List popular tags',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 20, help: 'Number of results' }],
+    columns: ['rank', 'name', 'posts'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 20);
+        const query = `query Tags {
+      tags(input: {terms: {view: "coreTags", limit: ${limit}}}) {
+        results { _id name slug postCount }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const tags = (data?.tags?.results ?? []);
+        return tags.map((item, i) => ({
+            rank: i + 1,
+            name: item.name ?? '',
+            posts: item.postCount ?? 0,
+        }));
+    },
+});

package/dist/clis/lesswrong/top-month.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, daysAgo, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'top-month',
+    description: 'Top this month',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "top", after: "${daysAgo(30)}", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/top-week.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, daysAgo, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'top-week',
+    description: 'Top this week',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "top", after: "${daysAgo(7)}", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/top-year.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, daysAgo, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'top-year',
+    description: 'Top this year',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "top", after: "${daysAgo(365)}", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/top.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlRequest } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'top',
+    description: 'Top all-time',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'limit', type: 'int', default: 10, help: 'Number of results' }],
+    columns: ['rank', 'title', 'author', 'karma', 'comments', 'url'],
+    func: async (_page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 10);
+        const query = `query PostsList {
+      posts(input: {terms: {view: "top", limit: ${limit}}}) {
+        results { _id title user { displayName } baseScore commentCount slug postedAt tags { name } }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.user?.displayName ?? 'Unknown',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/user-posts.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { DOMAIN, SITE, gqlEscape, gqlRequest, resolveUserId } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'user-posts',
+    description: "List a user's posts",
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'username',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'LessWrong username or slug',
+        },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'karma', 'comments', 'date', 'url'],
+    func: async (_page, kwargs) => {
+        const username = String(kwargs.username);
+        const limit = Number(kwargs.limit ?? 10);
+        const user = await resolveUserId(username);
+        const query = `query UserPosts {
+      posts(input: {terms: {view: "userPosts", userId: "${gqlEscape(user._id)}", limit: ${limit}}}) {
+        results { _id title baseScore commentCount slug postedAt }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const posts = (data?.posts?.results ?? []);
+        return posts.map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            karma: item.baseScore ?? 0,
+            comments: item.commentCount ?? 0,
+            date: item.postedAt ?? '',
+            url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,
+        }));
+    },
+});

package/dist/clis/lesswrong/user.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../src/registry.js';
+import { EmptyResultError } from '../../src/errors.js';
+import { DOMAIN, SITE, gqlEscape, gqlRequest, stripHtml } from './_helpers.js';
+cli({
+    site: SITE,
+    name: 'user',
+    description: 'User profile',
+    domain: DOMAIN,
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'username',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'LessWrong username or slug',
+        },
+    ],
+    columns: ['field', 'value'],
+    func: async (_page, kwargs) => {
+        const slug = gqlEscape(String(kwargs.username).toLowerCase());
+        const query = `query UserProfile {
+      user(input: {selector: {slug: "${slug}"}}) {
+        result { _id displayName slug bio karma postCount commentCount createdAt }
+      }
+    }`;
+        const data = await gqlRequest(query);
+        const user = data?.user?.result;
+        if (!user?._id) {
+            throw new EmptyResultError(`lesswrong user ${String(kwargs.username)}`, 'Check the username — LessWrong slugs are lowercase (e.g. "zvi", "eliezer-yudkowsky")');
+        }
+        return [
+            { field: 'Name', value: user.displayName ?? '' },
+            { field: 'Username', value: user.slug ?? '' },
+            { field: 'Karma', value: user.karma ?? 0 },
+            { field: 'Posts', value: user.postCount ?? 0 },
+            { field: 'Comments', value: user.commentCount ?? 0 },
+            { field: 'Joined', value: user.createdAt ?? '' },
+            { field: 'Bio', value: stripHtml(user.bio ?? '') },
+            { field: 'URL', value: `https://${DOMAIN}/users/${user.slug}` },
+        ];
+    },
+});

package/dist/clis/linkedin/search.js

@@ -1,5 +1,5 @@
-import { cli, Strategy } from '../../registry.js';
-import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../src/registry.js';
+import { ArgumentError, CommandExecutionError } from '../../src/errors.js';
 // ── Filter value mappings ──────────────────────────────────────────────
 const EXPERIENCE_LEVELS = {
     internship: '1',

package/dist/clis/linkedin/timeline.js

@@ -1,5 +1,5 @@
-import { cli, Strategy } from '../../registry.js';
-import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+import { cli, Strategy } from '../../src/registry.js';
+import { AuthRequiredError, EmptyResultError } from '../../src/errors.js';
 function normalizeWhitespace(value) {
     return String(value ?? '').replace(/\s+/g, ' ').trim();
 }

package/dist/clis/linkedin/timeline.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { getRegistry } from '../../registry.js';
+import { getRegistry } from '../../src/registry.js';
 import './timeline.js';
 const { parseMetric, buildPostId, mergeTimelinePosts } = await import('./timeline.js').then((m) => m.__test__);
 describe('linkedin timeline adapter', () => {

package/dist/clis/linux-do/category.js

@@ -1,4 +1,4 @@
-import { cli, Strategy } from '../../registry.js';
+import { cli, Strategy } from '../../src/registry.js';
 import { buildLinuxDoCompatFooter, executeLinuxDoFeed } from './feed.js';
 cli({
     site: 'linux-do',