openalmanac 0.3.4 → 0.3.5

package/dist/tools/articles.js

@@ -2,37 +2,10 @@ import { z } from "zod";
 import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { stringify as yamlStringify } from "yaml";
-import { request, ARTICLES_DIR } from "../auth.js";
+import { request, ARTICLES_DIR, getAuthStatus } from "../auth.js";
 import { validateArticle, parseFrontmatter } from "../validate.js";
 import { openBrowser } from "../browser.js";
 const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-function slugify(title) {
-    return title
-        .toLowerCase()
-        .normalize("NFD")
-        .replace(/[\u0300-\u036f]/g, "")
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .replace(/-{2,}/g, "-");
-}
-/**
- * Workaround for Claude Agent SDK MCP transport bug (#18260):
- * Array/object parameters are sometimes serialized as JSON strings
- * instead of native values. This preprocessor coerces them back.
- */
-function coerceJson(schema) {
-    return z.preprocess((val) => {
-        if (typeof val === "string") {
-            try {
-                return JSON.parse(val);
-            }
-            catch {
-                return val;
-            }
-        }
-        return val;
-    }, schema);
-}
 const WRITING_GUIDE = `
 ## Article structure
 
@@ -151,79 +124,21 @@ External image URLs are auto-persisted on publish — no extra steps needed.
 function ensureArticlesDir() {
     mkdirSync(ARTICLES_DIR, { recursive: true });
 }
-function resolveArticleDir(communitySlug) {
-    return communitySlug ? join(ARTICLES_DIR, communitySlug) : ARTICLES_DIR;
-}
-function resolveArticlePaths(slug, communitySlug) {
-    const dir = resolveArticleDir(communitySlug);
-    return {
-        dir,
-        filePath: join(dir, `${slug}.md`),
-        originalPath: join(dir, `.${slug}.original.md`),
-    };
-}
-function findDraftCandidates(slug) {
-    const matches = [];
-    const root = resolveArticlePaths(slug);
-    if (existsSync(root.filePath)) {
-        matches.push({ communitySlug: null, filePath: root.filePath, originalPath: root.originalPath });
-    }
-    try {
-        const dirs = readdirSync(ARTICLES_DIR).filter((d) => {
-            try {
-                return statSync(join(ARTICLES_DIR, d)).isDirectory();
-            }
-            catch {
-                return false;
-            }
-        });
-        for (const communitySlug of dirs) {
-            const scoped = resolveArticlePaths(slug, communitySlug);
-            if (existsSync(scoped.filePath)) {
-                matches.push({ communitySlug, filePath: scoped.filePath, originalPath: scoped.originalPath });
-            }
-        }
-    }
-    catch { /* ignore readdir errors */ }
-    return matches;
-}
-function resolvePublishCandidate(slug, communitySlug) {
-    if (communitySlug) {
-        const paths = resolveArticlePaths(slug, communitySlug);
-        if (!existsSync(paths.filePath)) {
-            throw new Error(`File not found: ${paths.filePath}\nUse download to get an existing article or new to create a scaffold.`);
-        }
-        return { communitySlug, ...paths };
-    }
-    const matches = findDraftCandidates(slug);
-    if (matches.length === 0) {
-        const fallback = resolveArticlePaths(slug);
-        throw new Error(`File not found: ${fallback.filePath}\nUse download to get an existing article or new to create a scaffold.`);
-    }
-    if (matches.length > 1) {
-        const paths = matches.map((match) => `  - ${match.filePath}`).join("\n");
-        throw new Error(`Multiple local drafts found for slug "${slug}". Publish is ambiguous.\n${paths}\nRemove the duplicate draft or publish with community_slug set.`);
-    }
-    return matches[0];
-}
 export function registerArticleTools(server) {
     server.addTool({
         name: "search_articles",
         description: "Search existing OpenAlmanac articles and stubs. Accepts multiple queries for batch lookup. " +
             "Use this to check if articles or stubs exist before creating them, or to find entity slugs for wikilinks. " +
-            "Results include 'stub' field (true/false) and 'entity_type' field. " +
-            "Pass community_slug to restrict results to articles owned by that community wiki (does not include global articles). No authentication needed.",
+            "Results include 'stub' field (true/false) and 'entity_type' field. No authentication needed.",
         parameters: z.object({
-            queries: coerceJson(z.array(z.string()).min(1).max(20)).describe("Search queries (1-20)"),
+            queries: z.array(z.string()).min(1).max(20).describe("Search queries (1-20)"),
             limit: z.number().default(5).describe("Max results per query (1-50, default 5)"),
             include_stubs: z.boolean().default(true).describe("Include stub articles in results (default true)"),
-            community_slug: z.string().optional().describe("Optional community slug. When set, results are restricted to articles owned by that community wiki only — global articles are excluded. Omit to search all of OpenAlmanac."),
         }),
-        async execute({ queries, limit, include_stubs, community_slug }) {
-            const json = { queries, limit, include_stubs };
-            if (community_slug)
-                json.community_slug = community_slug;
-            const resp = await request("POST", "/api/search/batch", { json });
+        async execute({ queries, limit, include_stubs }) {
+            const resp = await request("POST", "/api/search/batch", {
+                json: { queries, limit, include_stubs },
+            });
             return JSON.stringify(await resp.json(), null, 2);
         },
     });
@@ -233,247 +148,192 @@ export function registerArticleTools(server) {
             "Use this to reference or summarize existing articles in conversation. " +
             "For editing articles locally, use 'download' instead. No authentication needed.",
         parameters: z.object({
-            slugs: coerceJson(z.array(z.string()).min(1).max(20)).describe("Article slugs to read (1-20)"),
-            community_slug: z.string().optional().describe("Community slug for reading community-owned wiki articles. Omit for global almanac articles."),
+            slugs: z.array(z.string()).min(1).max(20).describe("Article slugs to read (1-20)"),
         }),
-        async execute({ slugs, community_slug }) {
-            const json = { slugs };
-            if (community_slug)
-                json.community_slug = community_slug;
-            const resp = await request("POST", "/api/articles/batch", { json });
+        async execute({ slugs }) {
+            const resp = await request("POST", "/api/articles/batch", {
+                json: { slugs },
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "create_stubs",
+        description: "Create stub articles — placeholders for entities that don't have full articles yet. " +
+            "Use this for every entity (person, organization, topic, etc.) mentioned in an article. " +
+            "Idempotent: existing slugs return their current status. Requires login.",
+        parameters: z.object({
+            stubs: z.array(z.object({
+                slug: z
+                    .string()
+                    .min(1)
+                    .max(500)
+                    .describe("Unique kebab-case identifier. For people with LinkedIn: use their vanity ID (e.g. 'john-smith-4a8b2c1'). " +
+                    "For others: descriptive kebab-case (e.g. 'reinforcement-learning', 'openai')"),
+                title: z.string().describe("Display title (e.g. 'John Smith', 'Reinforcement Learning')"),
+                entity_type: z
+                    .enum(["person", "organization", "topic", "event", "creative_work", "place"])
+                    .optional()
+                    .describe("Entity type: 'person' for individuals, 'organization' for companies/institutions/nonprofits, " +
+                    "'topic' for concepts/fields/technologies, 'event' for conferences/historical events, " +
+                    "'creative_work' for books/papers/films/software, 'place' for cities/countries/landmarks"),
+                headline: z
+                    .string()
+                    .optional()
+                    .describe("Short headline (e.g. 'Professor of CS at MIT', 'AI research laboratory')"),
+                image_url: z.string().url().optional().describe("Image URL for the entity"),
+                summary: z
+                    .string()
+                    .optional()
+                    .describe("2-4 sentence summary of the entity. This becomes the stub page content. " +
+                    "Be informative — include key facts, dates, and context."),
+            })).min(1).max(50).describe("Stubs to create (1-50)"),
+        }),
+        async execute({ stubs }) {
+            const resp = await request("POST", "/api/articles/stubs", {
+                auth: true,
+                json: { stubs },
+            });
             return JSON.stringify(await resp.json(), null, 2);
         },
     });
     server.addTool({
         name: "download",
-        description: "Download articles to your local workspace for editing. " +
-            "Global articles: ~/.openalmanac/articles/{slug}.md. Community wiki: ~/.openalmanac/articles/{community_slug}/{slug}.md. " +
-            "Returns a writing guide on first call. After editing, use publish to push changes.",
+        description: "Download an article to your local workspace for editing. The file is saved to ~/.openalmanac/articles/{slug}.md " +
+            "with YAML frontmatter. Returns a writing guide covering article structure, infobox format, citations, and quality rules. " +
+            "After editing, use 'publish' to push your changes live.",
         parameters: z.object({
-            slugs: coerceJson(z.array(z.string()).min(1).max(50)).describe("Article slugs to download (1-50)"),
-            community_slug: z.string().optional().describe("Community slug for community-owned wiki articles"),
+            slug: z.string().describe("Article slug (e.g. 'machine-learning')"),
         }),
-        async execute({ slugs, community_slug }) {
-            for (const slug of slugs) {
-                if (!SLUG_RE.test(slug)) {
-                    throw new Error(`Invalid slug "${slug}". Must be kebab-case (e.g. 'machine-learning').`);
-                }
+        async execute({ slug }) {
+            if (!SLUG_RE.test(slug)) {
+                throw new Error(`Invalid slug "${slug}". Must be kebab-case (e.g. 'machine-learning').`);
             }
-            const json = { slugs };
-            if (community_slug)
-                json.community_slug = community_slug;
-            const resp = await request("POST", "/api/articles/batch-download", { json });
-            const data = (await resp.json());
+            const resp = await request("GET", `/api/articles/${slug}`, {
+                params: { format: "md" },
+            });
+            const markdown = await resp.text();
             ensureArticlesDir();
-            const lines = [];
-            for (const slug of slugs) {
-                if (data.errors[slug]) {
-                    lines.push(`FAILED ${slug}: ${data.errors[slug]}`);
-                    continue;
-                }
-                const markdown = data.articles[slug];
-                if (!markdown) {
-                    lines.push(`FAILED ${slug}: missing from response`);
-                    continue;
-                }
-                const { dir, filePath, originalPath } = resolveArticlePaths(slug, community_slug);
-                if (community_slug) {
-                    mkdirSync(dir, { recursive: true });
-                }
-                writeFileSync(filePath, markdown, "utf-8");
-                writeFileSync(originalPath, markdown, "utf-8");
-                const { frontmatter, content } = parseFrontmatter(markdown);
-                const title = frontmatter.title || "(untitled)";
-                const wordCount = content.trim().split(/\s+/).filter(Boolean).length;
-                const isStub = frontmatter.stub === true;
-                const stubNote = isStub
-                    ? "\n\nThis is a STUB article — a placeholder that hasn't been fully written yet. " +
-                        "Fill in the content body with a complete article, then push to publish."
-                    : "";
-                lines.push(`Downloaded "${title}" to ${filePath}\n${wordCount} words, ${frontmatter.sources?.length ?? 0} sources.${stubNote}`);
-            }
-            return [lines.join("\n"), "", WRITING_GUIDE].join("\n");
+            const filePath = join(ARTICLES_DIR, `${slug}.md`);
+            writeFileSync(filePath, markdown, "utf-8");
+            const originalPath = join(ARTICLES_DIR, `.${slug}.original.md`);
+            writeFileSync(originalPath, markdown, "utf-8");
+            const { frontmatter, content } = parseFrontmatter(markdown);
+            const title = frontmatter.title || "(untitled)";
+            const wordCount = content.trim().split(/\s+/).filter(Boolean).length;
+            const isStub = frontmatter.stub === true;
+            const stubNote = isStub
+                ? "\n\nThis is a STUB article — a placeholder that hasn't been fully written yet. " +
+                    "Fill in the content body with a complete article, then push to publish."
+                : "";
+            return `Downloaded "${title}" to ${filePath}\n${wordCount} words, ${frontmatter.sources?.length ?? 0} sources.${stubNote}\n\n${WRITING_GUIDE}`;
         },
     });
     server.addTool({
         name: "new",
-        description: "Scaffold new articles locally. Creates .md files with YAML frontmatter and empty bodies. " +
-            "Provide explicit slugs when you know the canonical ID; otherwise they are auto-derived from titles. For community wiki articles, provide community_slug. " +
-            "After writing content, use publish to go live.",
+        description: "Create a new article scaffold in your local working directory (~/.openalmanac/articles/). " +
+            "The file is created with YAML frontmatter and an empty body. Returns a writing guide covering article structure, infobox format, citations, and quality rules. " +
+            "Edit the file to add content and sources, then use publish to go live.",
         parameters: z.object({
-            articles: coerceJson(z.array(z.object({
-                title: z.string().describe("Article title"),
-                slug: z.string().optional().describe("Optional explicit kebab-case slug. Encouraged when you know the canonical ID."),
-                topics: z.array(z.string()).optional().describe("Topic slugs for community wiki articles"),
-            })).min(1).max(50)).describe("Articles to scaffold (1-50)"),
-            community_slug: z.string().optional().describe("Community slug for community-owned wiki articles"),
+            slug: z
+                .string()
+                .describe("Unique kebab-case identifier (e.g. 'machine-learning'). Pattern: ^[a-z0-9]+(-[a-z0-9]+)*$"),
+            title: z.string().describe("Article title"),
         }),
-        async execute({ articles, community_slug }) {
-            if (community_slug && !SLUG_RE.test(community_slug)) {
-                throw new Error(`Invalid community_slug "${community_slug}". Must be kebab-case.`);
+        async execute({ slug, title }) {
+            if (!SLUG_RE.test(slug)) {
+                throw new Error(`Invalid slug "${slug}". Must be kebab-case (e.g. 'machine-learning'). Pattern: ^[a-z0-9]+(-[a-z0-9]+)*$`);
             }
             ensureArticlesDir();
-            let dir = ARTICLES_DIR;
-            if (community_slug) {
-                dir = join(ARTICLES_DIR, community_slug);
-                mkdirSync(dir, { recursive: true });
-            }
-            const created = [];
-            const skipped = [];
-            for (const item of articles) {
-                const slug = item.slug || slugify(item.title);
-                if (!slug) {
-                    skipped.push(`(empty slug from title: "${item.title}")`);
-                    continue;
-                }
-                if (!SLUG_RE.test(slug)) {
-                    skipped.push(`"${item.title}" → invalid slug "${slug}"`);
-                    continue;
-                }
-                const filePath = join(dir, `${slug}.md`);
-                if (existsSync(filePath)) {
-                    skipped.push(`${slug}.md already exists — skipped`);
-                    continue;
-                }
-                const meta = { article_id: slug, title: item.title };
-                if (community_slug)
-                    meta.community_slug = community_slug;
-                if (item.topics && item.topics.length > 0)
-                    meta.topics = item.topics;
-                meta.sources = [];
-                const frontmatter = yamlStringify(meta);
-                const scaffold = `---\n${frontmatter}---\n\n`;
-                writeFileSync(filePath, scaffold, "utf-8");
-                created.push(filePath);
+            const filePath = join(ARTICLES_DIR, `${slug}.md`);
+            if (existsSync(filePath)) {
+                throw new Error(`File already exists: ${filePath}\nUse download to refresh it, or publish to push changes.`);
             }
-            const parts = [
-                created.length > 0 ? `Created ${created.length} file(s):\n${created.map((p) => `  - ${p}`).join("\n")}` : "No new files created.",
-                skipped.length > 0 ? `Skipped:\n${skipped.map((s) => `  - ${s}`).join("\n")}` : "",
-                WRITING_GUIDE,
-            ];
-            return parts.filter(Boolean).join("\n\n");
+            const frontmatter = yamlStringify({ article_id: slug, title, sources: [] });
+            const scaffold = `---\n${frontmatter}---\n\n`;
+            writeFileSync(filePath, scaffold, "utf-8");
+            return `Created ${filePath}\n\n${WRITING_GUIDE}`;
         },
     });
     server.addTool({
         name: "publish",
-        description: "Validate and publish articles from your local workspace. " +
-            "Provide specific slugs, or a community_slug to publish all articles in that community folder. " +
-            "Empty-body files become stubs. Dead wikilinks auto-create stubs on the server. " +
-            "Put edit_summary in frontmatter for per-article change descriptions. Requires login.",
+        description: "Validate and publish an article from your local workspace. Reads ~/.openalmanac/articles/{slug}.md, " +
+            "validates content and sources, and publishes to OpenAlmanac. Requires login.",
         parameters: z.object({
-            slugs: coerceJson(z.array(z.string()).min(1).max(50)).optional()
-                .describe("Specific article slugs to publish"),
-            community_slug: z.string().optional()
-                .describe("Publish all .md files in this community folder under ~/.openalmanac/articles/"),
+            slug: z.string().describe("Article slug matching the filename (without .md)"),
+            change_title: z.string().optional().describe("Short title for the change (e.g. 'Added early life section')"),
+            change_description: z.string().optional().describe("Longer description of what changed and why"),
         }),
-        async execute({ slugs, community_slug }) {
-            if (!slugs?.length && !community_slug) {
-                throw new Error("Provide slugs or community_slug (explicit intent required).");
+        async execute({ slug, change_title, change_description }) {
+            if (!SLUG_RE.test(slug)) {
+                throw new Error(`Invalid slug "${slug}". Must be kebab-case (e.g. 'machine-learning').`);
             }
-            const tasks = [];
-            if (community_slug && !slugs?.length) {
-                if (!SLUG_RE.test(community_slug)) {
-                    throw new Error(`Invalid community_slug "${community_slug}". Must be kebab-case.`);
-                }
-                const dir = join(ARTICLES_DIR, community_slug);
-                if (!existsSync(dir)) {
-                    throw new Error(`Community folder not found: ${dir}`);
-                }
-                const files = readdirSync(dir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
-                if (files.length === 0) {
-                    throw new Error(`No .md files in ${dir}`);
-                }
-                for (const f of files) {
-                    const slug = f.replace(/\.md$/i, "");
-                    tasks.push({ slug, communitySlug: community_slug, ...resolveArticlePaths(slug, community_slug) });
-                }
+            const filePath = join(ARTICLES_DIR, `${slug}.md`);
+            let raw;
+            try {
+                raw = readFileSync(filePath, "utf-8");
             }
-            else if (slugs?.length) {
-                for (const slug of slugs) {
-                    if (!SLUG_RE.test(slug)) {
-                        throw new Error(`Invalid slug "${slug}". Must be kebab-case (e.g. 'machine-learning').`);
-                    }
-                    tasks.push({ slug, ...resolvePublishCandidate(slug, community_slug ?? undefined) });
-                }
+            catch {
+                throw new Error(`File not found: ${filePath}\nUse download to get an existing article or new to create a scaffold.`);
             }
-            const validationLines = [];
-            const validArticles = [];
-            for (const task of tasks) {
-                const raw = readFileSync(task.filePath, "utf-8");
-                const errors = validateArticle(raw);
-                if (errors.length > 0) {
-                    const lines = errors.map((e) => `  ${e.field}: ${e.message}`);
-                    validationLines.push(`FAILED ${task.slug}: Validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):\n${lines.join("\n")}`);
-                }
-                else {
-                    validArticles.push({ slug: task.slug, markdown: raw });
+            // Local validation
+            const errors = validateArticle(raw);
+            if (errors.length > 0) {
+                const lines = errors.map((e) => `  ${e.field}: ${e.message}`);
+                throw new Error(`Validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):\n${lines.join("\n")}\n\nFix the file and try again.`);
+            }
+            // Inject change_title/change_description into frontmatter if provided
+            let body = raw;
+            if (change_title || change_description) {
+                const { frontmatter, content } = parseFrontmatter(raw);
+                if (change_title)
+                    frontmatter.change_title = change_title;
+                if (change_description)
+                    frontmatter.change_description = change_description;
+                const newFrontmatter = yamlStringify(frontmatter);
+                body = `---\n${newFrontmatter}---\n${content}`;
+            }
+            const resp = await request("PUT", `/api/articles/${slug}`, {
+                auth: true,
+                body,
+                contentType: "text/markdown",
+            });
+            const data = (await resp.json());
+            const articleUrl = `https://www.openalmanac.org/article/${slug}?celebrate=true`;
+            openBrowser(articleUrl);
+            // Clean up local files after successful publish
+            let cleanupWarning = "";
+            try {
+                unlinkSync(filePath);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT") {
+                    cleanupWarning = `\nNote: could not remove local draft: ${e.message}`;
                 }
             }
-            const inGui = process.env.OPENALMANAC_GUI === "1";
-            const resultLines = [...validationLines];
-            let okCount = 0;
-            if (validArticles.length > 0) {
-                const resp = await request("POST", "/api/articles/batch-publish", {
-                    auth: true,
-                    json: { articles: validArticles },
-                });
-                const data = (await resp.json());
-                for (const r of data.results) {
-                    if (r.status === "failed") {
-                        resultLines.push(`FAILED ${r.slug}: ${r.error ?? "unknown error"}`);
-                        continue;
-                    }
-                    okCount += 1;
-                    const task = tasks.find((t) => t.slug === r.slug);
-                    if (task) {
-                        try {
-                            unlinkSync(task.filePath);
-                        }
-                        catch (e) {
-                            if (e.code !== "ENOENT") {
-                                resultLines.push(`Note: could not remove local draft for ${r.slug}: ${e.message}`);
-                            }
-                        }
-                        try {
-                            unlinkSync(task.originalPath);
-                        }
-                        catch (e) {
-                            if (e.code !== "ENOENT") {
-                                resultLines.push(`Note: could not remove original copy for ${r.slug}: ${e.message}`);
-                            }
-                        }
-                    }
-                    resultLines.push(`OK ${r.slug}: ${r.status}\n${JSON.stringify(r, null, 2)}`);
-                    if (!inGui && tasks.length === 1 && r.canonical_path) {
-                        const articleUrl = `https://www.openalmanac.org${r.canonical_path}?celebrate=true`;
-                        openBrowser(articleUrl);
-                    }
+            try {
+                unlinkSync(join(ARTICLES_DIR, `.${slug}.original.md`));
+            }
+            catch (e) {
+                if (e.code !== "ENOENT") {
+                    cleanupWarning += `\nNote: could not remove original copy: ${e.message}`;
                 }
             }
-            const urlHint = inGui
-                ? "\n\nThe article(s) have been published! Let the user know they're live. Do not send them to a web URL."
-                : tasks.length > 1
-                    ? "\n\n(Opening browser skipped for batch publish — share URLs from results above.)"
-                    : "";
-            return `Published ${okCount}/${tasks.length}.\n\n${resultLines.join("\n\n")}${urlHint}`;
+            return `Pushed successfully.\n\nArticle URL (share this exact link with the user): ${articleUrl}${cleanupWarning}\n\n${JSON.stringify(data, null, 2)}`;
         },
     });
     server.addTool({
-        name: "list_articles",
-        description: "Browse a community's wiki articles. Structured listing, not fuzzy search. " +
-            "Use this to see what exists, find stubs to fill, or discover most-referenced gaps.",
+        name: "requested_articles",
+        description: "List requested articles — stubs that are referenced by the most articles but haven't been fully written yet. " +
+            "Use this to find high-demand topics to write about. No authentication needed.",
         parameters: z.object({
-            community_slug: z.string().describe("Community slug"),
-            topic: z.string().optional().describe("Filter by topic slug"),
-            sort: z.enum(["recent", "most_referenced"]).default("recent").describe("Sort order"),
-            stubs_only: z.boolean().default(false).describe("Only return stubs"),
-            limit: z.number().min(1).max(200).default(50).describe("Max results (1-200)"),
+            limit: z.number().default(20).describe("Max results (1-200, default 20)"),
+            offset: z.number().default(0).describe("Pagination offset (default 0)"),
         }),
-        async execute({ community_slug, topic, sort, stubs_only, limit }) {
-            const params = { sort, stubs_only, limit };
-            if (topic)
-                params.topic = topic;
-            const resp = await request("GET", `/api/communities/${community_slug}/wiki`, { params });
+        async execute({ limit, offset }) {
+            const resp = await request("GET", "/api/articles/requested", {
+                params: { limit, offset },
+            });
             return JSON.stringify(await resp.json(), null, 2);
         },
     });
@@ -508,4 +368,34 @@ export function registerArticleTools(server) {
             return `Article Proposal: ${title}\n\n${summary}\n\nProceed with writing this article following the writing flow in your instructions.`;
         },
     });
+    server.addTool({
+        name: "status",
+        description: "Show login status and list all article files in your local working directory (~/.openalmanac/articles/). " +
+            "Shows auth state, filename, title, file size, and last modified time.",
+        async execute() {
+            ensureArticlesDir();
+            const auth = await getAuthStatus();
+            const authLine = auth.loggedIn
+                ? `Logged in as ${auth.name}.`
+                : "Not logged in. Use login to authenticate.";
+            const files = readdirSync(ARTICLES_DIR).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+            if (files.length === 0) {
+                return `${authLine}\n\nLocal articles (0 files in ${ARTICLES_DIR}):\n  (none — use download or new to get started)`;
+            }
+            const rows = [];
+            for (const file of files) {
+                const filePath = join(ARTICLES_DIR, file);
+                const stat = statSync(filePath);
+                const raw = readFileSync(filePath, "utf-8");
+                const { frontmatter } = parseFrontmatter(raw);
+                const title = frontmatter.title || "(untitled)";
+                const size = stat.size < 1024
+                    ? `${stat.size}B`
+                    : `${(stat.size / 1024).toFixed(1)}KB`;
+                const modified = stat.mtime.toISOString().slice(0, 16).replace("T", " ");
+                rows.push(`  ${file}  —  "${title}"  (${size}, modified ${modified})`);
+            }
+            return `${authLine}\n\nLocal articles (${files.length} file(s) in ${ARTICLES_DIR}):\n${rows.join("\n")}`;
+        },
+    });
 }

package/dist/tools/communities.js

@@ -4,7 +4,7 @@ export function registerCommunityTools(server) {
     server.addTool({
         name: "search_communities",
         description: "Search or list OpenAlmanac communities. Returns community names, descriptions, and member counts. " +
-            "Use this to discover communities by topic. No authentication needed.",
+            "Use this after pushing an article to find relevant communities for auto-linking. No authentication needed.",
         parameters: z.object({
             query: z
                 .string()
@@ -54,18 +54,11 @@ export function registerCommunityTools(server) {
                 .min(1)
                 .max(2000)
                 .describe("What the community is about (1-2000 chars)"),
-            cover_image_url: z.string().url().optional().describe("Hero/banner image URL. Use search_images to find a compelling image first."),
-            cover_image_position: z.number().min(0).max(100).optional().describe("Vertical focal point of cover image (0=top, 50=center, 100=bottom)"),
         }),
-        async execute({ name, slug, description, cover_image_url, cover_image_position }) {
-            const json = { name, slug, description };
-            if (cover_image_url)
-                json.cover_image_url = cover_image_url;
-            if (cover_image_position !== undefined)
-                json.cover_image_position = cover_image_position;
+        async execute({ name, slug, description }) {
             const resp = await request("POST", "/api/communities", {
                 auth: true,
-                json,
+                json: { name, slug, description },
             });
             const data = (await resp.json());
             const communityUrl = `https://www.openalmanac.org/communities/${slug}`;
@@ -98,4 +91,37 @@ export function registerCommunityTools(server) {
             return `Post created!\n\nURL: ${postUrl}\n\n${JSON.stringify(data, null, 2)}`;
         },
     });
+    server.addTool({
+        name: "link_article",
+        description: "Link an article to one or more communities. Use this after pushing an article to connect it " +
+            "with relevant communities. Call search_communities first to find matching communities. " +
+            "Idempotent — already-linked articles are reported but don't cause errors. Requires login.",
+        parameters: z.object({
+            article_id: z.string().describe("Article slug/ID to link (e.g. 'machine-learning')"),
+            community_slugs: z
+                .array(z.string())
+                .min(1)
+                .max(50)
+                .describe("List of community slugs to link the article to (max 50)"),
+        }),
+        async execute({ article_id, community_slugs }) {
+            const resp = await request("POST", `/api/articles/${article_id}/auto-link`, {
+                auth: true,
+                json: { community_slugs },
+            });
+            const data = (await resp.json());
+            const lines = [];
+            if (data.linked.length > 0) {
+                lines.push(`Linked to ${data.linked.length} communities: ${data.linked.join(", ")}`);
+            }
+            if (data.failed.length > 0) {
+                const failLines = data.failed.map((f) => `  ${f.slug}: ${f.reason}`);
+                lines.push(`Failed (${data.failed.length}):\n${failLines.join("\n")}`);
+            }
+            if (lines.length === 0) {
+                lines.push("No communities to link.");
+            }
+            return lines.join("\n\n");
+        },
+    });
 }

package/dist/tools/research.js

@@ -86,13 +86,14 @@ export function registerResearchTools(server) {
         name: "read_webpage",
         description: "Fetch a URL and return its content as markdown. Routes automatically based on URL:\n" +
             "- **Reddit threads** (reddit.com/r/{sub}/comments/{id}/...) — returns the post plus top-level threaded comments with scores and authors, via a residential proxy.\n" +
+            "- **Reddit wiki pages** (reddit.com/r/{sub}/wiki/...) — returns the wiki page as markdown with revision metadata.\n" +
             "- **YouTube videos** — returns title, description, transcript when available.\n" +
             "- **PDFs** — extracts text.\n" +
             "- **LinkedIn posts/profiles** — uses the LinkedIn scraper.\n" +
             "- **Everything else** — generic web scrape with Firecrawl/Jina fallback.\n\n" +
             "Requires API key. Rate limit: 5/min.",
         parameters: z.object({
-            url: z.string().url().describe("Full URL to read. For Reddit threads, use the canonical reddit.com/r/{sub}/comments/{id}/... form."),
+            url: z.string().url().describe("Full URL to read. For Reddit threads, use reddit.com/r/{sub}/comments/{id}/...; for Reddit wikis, use reddit.com/r/{sub}/wiki/... ."),
             max_length: z
                 .number()
                 .int()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openalmanac",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "OpenAlmanac — pull, edit, and push articles to the open knowledge base",
   "type": "module",
   "bin": {