planmode 0.2.2 → 0.4.0

package/src/lib/publisher.ts

@@ -2,10 +2,12 @@ import { readManifest, validateManifest } from "./manifest.js";
 import { getGitHubToken } from "./config.js";
 import { getRemoteUrl, getHeadSha, createTag, pushTag } from "./git.js";
 import { logger } from "./logger.js";
+import { withSpinner } from "./prompts.js";
 
 export interface PublishOptions {
   projectDir?: string;
   token?: string;
+  interactive?: boolean;
 }
 
 export interface PublishResult {
@@ -16,6 +18,7 @@ export interface PublishResult {
 
 export async function publishPackage(options: PublishOptions = {}): Promise<PublishResult> {
   const cwd = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? false;
 
   // Check auth
   const token = options.token ?? getGitHubToken();
@@ -24,12 +27,21 @@ export async function publishPackage(options: PublishOptions = {}): Promise<Publ
   }
 
   // Read and validate manifest
-  logger.info("Reading planmode.yaml...");
-  const manifest = readManifest(cwd);
-  const errors = validateManifest(manifest, true);
-  if (errors.length > 0) {
-    throw new Error(`Invalid manifest:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
-  }
+  const doValidate = async () => {
+    const manifest = readManifest(cwd);
+    const errors = validateManifest(manifest, true);
+    if (errors.length > 0) {
+      throw new Error(`Invalid manifest:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
+    }
+    return manifest;
+  };
+
+  const manifest = interactive
+    ? await withSpinner("Validating manifest...", doValidate, "Manifest valid")
+    : await (async () => {
+        logger.info("Reading planmode.yaml...");
+        return doValidate();
+      })();
 
   // Check git remote
   const remoteUrl = await getRemoteUrl(cwd);
@@ -41,162 +53,182 @@ export async function publishPackage(options: PublishOptions = {}): Promise<Publ
   const tag = `v${manifest.version}`;
 
   // Create and push tag
-  logger.info(`Creating tag ${tag}...`);
-  try {
-    await createTag(cwd, tag);
-  } catch {
-    logger.dim(`Tag ${tag} already exists, using existing`);
-  }
+  const doTag = async () => {
+    try {
+      await createTag(cwd, tag);
+    } catch {
+      // Tag already exists
+    }
+    try {
+      await pushTag(cwd, tag);
+    } catch {
+      // Tag already pushed
+    }
+  };
 
-  try {
-    await pushTag(cwd, tag);
+  if (interactive) {
+    await withSpinner(`Creating tag ${tag}...`, doTag, `Tag ${tag} ready`);
+  } else {
+    logger.info(`Creating tag ${tag}...`);
+    await doTag();
     logger.success(`Pushed tag ${tag}`);
-  } catch {
-    logger.dim(`Tag ${tag} already pushed`);
   }
 
   // Fork registry and create PR via GitHub API
-  logger.info("Submitting to registry...");
+  const doSubmit = async () => {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "planmode-cli",
+      "Content-Type": "application/json",
+    };
+
+    // Fork the registry repo (idempotent)
+    await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
+      method: "POST",
+      headers,
+    });
+
+    // Get authenticated user
+    const userRes = await fetch("https://api.github.com/user", { headers });
+    if (!userRes.ok) {
+      throw new Error("Failed to authenticate with GitHub. Check your token.");
+    }
+    const user = (await userRes.json()) as { login: string };
+
+    // Create metadata files content
+    const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+
+    const metadataContent = JSON.stringify(
+      {
+        name: manifest.name,
+        description: manifest.description,
+        author: manifest.author,
+        license: manifest.license,
+        repository: repoPath,
+        category: manifest.category ?? "other",
+        tags: manifest.tags ?? [],
+        type: manifest.type,
+        models: manifest.models ?? [],
+        latest_version: manifest.version,
+        versions: [manifest.version],
+        downloads: 0,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        dependencies: manifest.dependencies,
+        variables: manifest.variables,
+      },
+      null,
+      2,
+    );
+
+    const versionContent = JSON.stringify(
+      {
+        version: manifest.version,
+        published_at: new Date().toISOString(),
+        source: {
+          repository: repoPath,
+          tag,
+          sha,
+        },
+        files: ["planmode.yaml", manifest.content_file ?? "inline"],
+        content_hash: `sha256:${sha.slice(0, 16)}`,
+      },
+      null,
+      2,
+    );
 
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    Accept: "application/vnd.github.v3+json",
-    "User-Agent": "planmode-cli",
-    "Content-Type": "application/json",
-  };
+    // Create branch on fork
+    const branchName = `add-${manifest.name}-${manifest.version}`;
 
-  // Fork the registry repo (idempotent)
-  await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
-    method: "POST",
-    headers,
-  });
+    // Get main branch ref
+    const refRes = await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
+      { headers },
+    );
 
-  // Get authenticated user
-  const userRes = await fetch("https://api.github.com/user", { headers });
-  if (!userRes.ok) {
-    throw new Error("Failed to authenticate with GitHub. Check your token.");
-  }
-  const user = (await userRes.json()) as { login: string };
-
-  // Create metadata files content
-  const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
-
-  const metadataContent = JSON.stringify(
-    {
-      name: manifest.name,
-      description: manifest.description,
-      author: manifest.author,
-      license: manifest.license,
-      repository: repoPath,
-      category: manifest.category ?? "other",
-      tags: manifest.tags ?? [],
-      type: manifest.type,
-      models: manifest.models ?? [],
-      latest_version: manifest.version,
-      versions: [manifest.version],
-      downloads: 0,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-      dependencies: manifest.dependencies,
-      variables: manifest.variables,
-    },
-    null,
-    2,
-  );
-
-  const versionContent = JSON.stringify(
-    {
-      version: manifest.version,
-      published_at: new Date().toISOString(),
-      source: {
-        repository: repoPath,
-        tag,
-        sha,
-      },
-      files: ["planmode.yaml", manifest.content_file ?? "inline"],
-      content_hash: `sha256:${sha.slice(0, 16)}`,
-    },
-    null,
-    2,
-  );
-
-  // Create branch on fork
-  const branchName = `add-${manifest.name}-${manifest.version}`;
-
-  // Get main branch ref
-  const refRes = await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
-    { headers },
-  );
-
-  if (!refRes.ok) {
-    throw new Error("Failed to access registry fork. Make sure the fork exists.");
-  }
+    if (!refRes.ok) {
+      throw new Error("Failed to access registry fork. Make sure the fork exists.");
+    }
+
+    const refData = (await refRes.json()) as { object: { sha: string } };
+    const baseSha = refData.object.sha;
 
-  const refData = (await refRes.json()) as { object: { sha: string } };
-  const baseSha = refData.object.sha;
-
-  // Create branch
-  await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      ref: `refs/heads/${branchName}`,
-      sha: baseSha,
-    }),
-  });
-
-  // Create metadata.json
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
-    {
-      method: "PUT",
+    // Create branch
+    await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version}`,
-        content: Buffer.from(metadataContent).toString("base64"),
-        branch: branchName,
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha,
       }),
-    },
-  );
-
-  // Create version file
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-    {
-      method: "PUT",
+    });
+
+    // Create metadata.json
+    await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
+      {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({
+          message: `Add ${manifest.name}@${manifest.version}`,
+          content: Buffer.from(metadataContent).toString("base64"),
+          branch: branchName,
+        }),
+      },
+    );
+
+    // Create version file
+    await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
+      {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({
+          message: `Add ${manifest.name}@${manifest.version} version metadata`,
+          content: Buffer.from(versionContent).toString("base64"),
+          branch: branchName,
+        }),
+      },
+    );
+
+    // Create PR
+    const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version} version metadata`,
-        content: Buffer.from(versionContent).toString("base64"),
-        branch: branchName,
+        title: `Add ${manifest.name}@${manifest.version}`,
+        head: `${user.login}:${branchName}`,
+        base: "main",
+        body: `## New package: ${manifest.name}\n\n- **Type:** ${manifest.type}\n- **Version:** ${manifest.version}\n- **Description:** ${manifest.description}\n- **Author:** ${manifest.author}\n\nSubmitted via \`planmode publish\`.`,
       }),
-    },
-  );
-
-  // Create PR
-  const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      title: `Add ${manifest.name}@${manifest.version}`,
-      head: `${user.login}:${branchName}`,
-      base: "main",
-      body: `## New package: ${manifest.name}\n\n- **Type:** ${manifest.type}\n- **Version:** ${manifest.version}\n- **Description:** ${manifest.description}\n- **Author:** ${manifest.author}\n\nSubmitted via \`planmode publish\`.`,
-    }),
-  });
-
-  if (!prRes.ok) {
-    const err = await prRes.text();
-    throw new Error(`Failed to create PR: ${err}`);
-  }
+    });
+
+    if (!prRes.ok) {
+      const err = await prRes.text();
+      throw new Error(`Failed to create PR: ${err}`);
+    }
 
-  const pr = (await prRes.json()) as { html_url: string };
-  logger.success(`Published ${manifest.name}@${manifest.version}`);
-  logger.info(`PR: ${pr.html_url}`);
+    const pr = (await prRes.json()) as { html_url: string };
+    return pr.html_url;
+  };
+
+  let prUrl: string;
+  if (interactive) {
+    prUrl = await withSpinner(
+      "Submitting to registry...",
+      doSubmit,
+      "Submitted to registry",
+    );
+  } else {
+    logger.info("Submitting to registry...");
+    prUrl = await doSubmit();
+    logger.success(`Published ${manifest.name}@${manifest.version}`);
+    logger.info(`PR: ${prUrl}`);
+  }
 
   return {
-    prUrl: pr.html_url,
+    prUrl,
     packageName: manifest.name,
     version: manifest.version,
   };

package/src/mcp.ts

@@ -17,6 +17,7 @@ import { runDoctor } from "./lib/doctor.js";
 import { testPackage } from "./lib/tester.js";
 import { startRecordingAsync, stopRecording, isRecording } from "./lib/recorder.js";
 import { takeSnapshot } from "./lib/snapshot.js";
+import { addContextRepo, removeContextRepo, reindexContext, getContextSummary, formatSize } from "./lib/context.js";
 import type { Category } from "./types/index.js";
 
 // ── Helpers ──
@@ -784,6 +785,151 @@ server.registerTool(
   },
 );
 
+// -- planmode_context_add --
+server.registerTool(
+  "planmode_context_add",
+  {
+    description: "Add a document directory to the project context. Indexes all text-based files (md, pdf, txt, json, yaml, csv, html, etc.) and stores their metadata in .planmode/context.yaml. The AI can then see what documents are available and read them on demand.",
+    inputSchema: {
+      path: z.string().describe("Path to the document directory (relative to project or absolute)"),
+      name: z.string().optional().describe("Human-readable label for this directory"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)"),
+    },
+  },
+  async ({ path: dirPath, name, projectDir }) => {
+    try {
+      const { result, messages } = withCapture(() =>
+        addContextRepo(dirPath, { name, projectDir }),
+      );
+
+      const breakdown = result.files.length > 0
+        ? `\nTypes: ${getTypeBreakdownText(result)}`
+        : "";
+
+      return textResult(
+        formatMessages(
+          messages,
+          `Added "${name ?? result.repo.path}" — ${result.file_count} file(s), ${formatSize(result.total_size)}${breakdown}`,
+        ),
+      );
+    } catch (err) {
+      return errorResult("Error adding context repo", err as Error);
+    }
+  },
+);
+
+// -- planmode_context_remove --
+server.registerTool(
+  "planmode_context_remove",
+  {
+    description: "Remove a document directory from the project context",
+    inputSchema: {
+      pathOrName: z.string().describe("Path or name of the context repo to remove"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)"),
+    },
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(() =>
+        removeContextRepo(pathOrName, projectDir),
+      );
+
+      return textResult(formatMessages(messages) || `Removed "${pathOrName}" from context.`);
+    } catch (err) {
+      return errorResult("Error removing context repo", err as Error);
+    }
+  },
+);
+
+// -- planmode_context_list --
+server.registerTool(
+  "planmode_context_list",
+  {
+    description: "List all document directories in the project context with file counts, sizes, and type breakdowns. Use this to see what reference documents are available for the project.",
+    inputSchema: {
+      detailed: z.boolean().optional().describe("Include full file listings for each repo (default: false, shows only summaries)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)"),
+    },
+  },
+  async ({ detailed, projectDir }) => {
+    try {
+      const summary = getContextSummary(projectDir);
+
+      if (summary.totalRepos === 0) {
+        return textResult("No context repos configured. Use planmode_context_add to add a document directory.");
+      }
+
+      const lines = [
+        `**${summary.totalRepos} context repo(s)** — ${summary.totalFiles} file(s), ${formatSize(summary.totalSize)}`,
+        "",
+      ];
+
+      for (const repo of summary.repos) {
+        lines.push(`### ${repo.name}`);
+        lines.push(`- **Path:** ${repo.path}`);
+        lines.push(`- **Files:** ${repo.fileCount} (${formatSize(repo.totalSize)})`);
+        if (repo.typeBreakdown.length > 0) {
+          lines.push(`- **Types:** ${repo.typeBreakdown.join(", ")}`);
+        }
+        lines.push(`- **Indexed:** ${repo.indexedAt}`);
+
+        if (detailed) {
+          const index = (await import("./lib/context.js")).readContextIndex(projectDir);
+          const repoIndex = index.repos.find(
+            (r) => r.repo.path === repo.path || r.repo.name === repo.name,
+          );
+          if (repoIndex && repoIndex.files.length > 0) {
+            lines.push("", "**Files:**");
+            for (const file of repoIndex.files) {
+              lines.push(`- \`${file.path}\` (${file.extension}, ${formatSize(file.size)})`);
+            }
+          }
+        }
+
+        lines.push("");
+      }
+
+      return textResult(lines.join("\n"));
+    } catch (err) {
+      return errorResult("Error listing context", err as Error);
+    }
+  },
+);
+
+// -- planmode_context_reindex --
+server.registerTool(
+  "planmode_context_reindex",
+  {
+    description: "Re-scan files in one or all context directories to update the file index",
+    inputSchema: {
+      pathOrName: z.string().optional().describe("Path or name of a specific repo to reindex (omit to reindex all)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)"),
+    },
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(() =>
+        reindexContext(pathOrName, projectDir),
+      );
+
+      return textResult(formatMessages(messages) || "Reindex complete.");
+    } catch (err) {
+      return errorResult("Error reindexing context", err as Error);
+    }
+  },
+);
+
+function getTypeBreakdownText(repoIndex: { files: Array<{ extension: string }> }): string {
+  const counts = new Map<string, number>();
+  for (const file of repoIndex.files) {
+    counts.set(file.extension, (counts.get(file.extension) ?? 0) + 1);
+  }
+  return Array.from(counts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .map(([ext, count]) => `${ext}: ${count}`)
+    .join(", ");
+}
+
 // ── Resources ──
 
 // Expose installed packages as browsable resources

package/src/types/index.ts

@@ -133,6 +133,34 @@ export interface PlanmodeConfig {
   };
 }
 
+// ── Context (document indexing) ──
+
+export interface ContextRepo {
+  path: string;
+  name?: string;
+  added_at: string;
+}
+
+export interface IndexedFile {
+  path: string;
+  extension: string;
+  size: number;
+  modified_at: string;
+}
+
+export interface ContextRepoIndex {
+  repo: ContextRepo;
+  files: IndexedFile[];
+  indexed_at: string;
+  file_count: number;
+  total_size: number;
+}
+
+export interface ContextIndex {
+  version: number;
+  repos: ContextRepoIndex[];
+}
+
 // ── Resolved package info ──
 
 export interface ResolvedPackage {