@agentproto/corpus-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/cli.mjs

@@ -7,11 +7,12 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { z } from 'zod';
 import { randomBytes, randomUUID } from 'crypto';
 import { readFileSync, existsSync } from 'fs';
-import { buildDistillPrompt, parseItems, isRefinedKind, SyncRunner, resolveKnowledge, DistillRunner, systemClock, WebImporter, ImporterRunner, CorpusEventEmitter, CorpusWorkspaceReader, CorpusLinter, CorpusValidator, normalizeLanguageTag } from '@agentproto/corpus';
+import { buildDistillPrompt, parseItems, isRefinedKind, SyncRunner, resolveKnowledge, DistillRunner, systemClock, WebImporter, ImporterRunner, CorpusEventEmitter, CorpusWorkspaceReader, CorpusLinter, CorpusValidator, ReadOnlyFs, normalizeLanguageTag } from '@agentproto/corpus';
 import matter2 from 'gray-matter';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { parseClaudeJsonOutput, spawnWithStdin } from '@agentproto/cli-exec';
+import { stitchReport, buildPacks, reportConfigSchema } from '@agentproto/corpus/report';
 
 /**
  * @agentproto/corpus-cli v0.1.0-alpha
@@ -103,9 +104,9 @@ function resolvePackageJson(packageName) {
   }
   return null;
 }
-async function readJsonIfExists(path4) {
+async function readJsonIfExists(path5) {
   try {
-    const raw = await readFile(path4, "utf8");
+    const raw = await readFile(path5, "utf8");
     return JSON.parse(raw);
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
@@ -114,9 +115,9 @@ async function readJsonIfExists(path4) {
 }
 async function readConfiguredPresetPackages() {
   const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
-  const path4 = join(base, "config.json");
+  const path5 = join(base, "config.json");
   try {
-    const raw = await readFile(path4, "utf8");
+    const raw = await readFile(path5, "utf8");
     const parsed = JSON.parse(raw);
     const list = parsed.corpusPresetPackages;
     if (Array.isArray(list) && list.length > 0) return list;
@@ -453,6 +454,10 @@ Run \`corpus init --list\` for available presets.`,
       2
     );
   }
+  if (!presetSlug) {
+    const nameErr = invalidCorpusName(name);
+    if (nameErr) return fail(nameErr, 2);
+  }
   const target = resolveWorkspacePath(pathArg);
   const fs = new NodeFsAdapter({ root: target });
   if (await fs.exists("KNOWLEDGE.md")) {
@@ -507,6 +512,19 @@ Try: corpus import-web ${pathArg ?? "."} --urls-file urls.txt
   );
   return 0;
 }
+var CORPUS_NAME_RE = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+function invalidCorpusName(name) {
+  if (name.length >= 2 && name.length <= 96 && CORPUS_NAME_RE.test(name)) {
+    return null;
+  }
+  const suggestion = slugifyName(name);
+  const hint = suggestion.length >= 2 && CORPUS_NAME_RE.test(suggestion) ? `
+Did you mean: ${suggestion}` : "";
+  return `init: invalid corpus name "${name}". A corpus name is a kebab-case identifier \u2014 lowercase letters, digits and hyphens, 2\u201396 chars, starting with a letter and ending alphanumerically (^[a-z][a-z0-9-]*[a-z0-9]$).${hint}`;
+}
+function slugifyName(raw) {
+  return raw.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
 function splitList(v) {
   return (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 }
@@ -1126,18 +1144,18 @@ var AssemblyAiStt = class {
       ...job.language_code ? { language: job.language_code } : {}
     };
   }
-  async post(path4, body) {
-    const r = await fetch(`${this.baseUrl}${path4}`, {
+  async post(path5, body) {
+    const r = await fetch(`${this.baseUrl}${path5}`, {
       method: "POST",
       headers: { authorization: this.apiKey, "content-type": "application/json" },
       body: JSON.stringify(body)
     });
-    if (!r.ok) throw new Error(`AssemblyAI POST ${path4} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    if (!r.ok) throw new Error(`AssemblyAI POST ${path5} ${r.status}: ${(await r.text()).slice(0, 200)}`);
     return AAI_TRANSCRIPT.parse(await r.json());
   }
-  async get(path4) {
-    const r = await fetch(`${this.baseUrl}${path4}`, { headers: { authorization: this.apiKey } });
-    if (!r.ok) throw new Error(`AssemblyAI GET ${path4} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+  async get(path5) {
+    const r = await fetch(`${this.baseUrl}${path5}`, { headers: { authorization: this.apiKey } });
+    if (!r.ok) throw new Error(`AssemblyAI GET ${path5} ${r.status}: ${(await r.text()).slice(0, 200)}`);
     return AAI_TRANSCRIPT.parse(await r.json());
   }
 };
@@ -2003,13 +2021,13 @@ async function readSources(root) {
   const out = [];
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".md")) continue;
-    const path4 = join(e.parentPath, e.name);
+    const path5 = join(e.parentPath, e.name);
     try {
-      const parsed = matter2(await readFile(path4, "utf-8"));
+      const parsed = matter2(await readFile(path5, "utf-8"));
       const fm = SOURCE_FRONTMATTER.parse(parsed.data);
       if (!fm.id || !parsed.content.trim()) continue;
       out.push({
-        path: path4,
+        path: path5,
         id: fm.id,
         title: fm.title ?? fm.id,
         body: parsed.content.trim(),
@@ -2168,6 +2186,126 @@ async function runKnowledge(args) {
   }
   return 0;
 }
+async function runReport(args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "packs":
+      return await runReportPacks(rest);
+    case "stitch":
+      return await runReportStitch(rest);
+    case void 0:
+      return fail("report needs a subcommand (packs | stitch). Try --help.", 2);
+    default:
+      return fail(`unknown report subcommand "${sub}". Try --help.`, 2);
+  }
+}
+function loadReportConfig(configPath) {
+  const raw = readFileSync(path.resolve(process.cwd(), configPath), "utf8");
+  return reportConfigSchema.parse(JSON.parse(raw));
+}
+async function runReportPacks(args) {
+  let dataset;
+  let configPath;
+  let out;
+  let viewsDir;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--config":
+        configPath = next();
+        break;
+      case "--out":
+        out = next();
+        break;
+      case "--views-dir":
+        viewsDir = next();
+        break;
+      default:
+        if (!a.startsWith("-") && dataset === void 0) dataset = a;
+    }
+  }
+  const datasetPath = resolveWorkspacePath(dataset);
+  if (!configPath) {
+    return fail("report packs needs --config <report.config.json>.", 2);
+  }
+  let config;
+  try {
+    config = loadReportConfig(configPath);
+  } catch (err) {
+    return fail(
+      `could not load/validate config "${configPath}": ${err instanceof Error ? err.message : String(err)}`,
+      2
+    );
+  }
+  const reportRoot = out ? path.resolve(process.cwd(), out) : datasetPath;
+  const datasetFs = new ReadOnlyFs(new NodeFsAdapter({ root: datasetPath }));
+  const reportFs = new NodeFsAdapter({ root: reportRoot });
+  const result = await buildPacks({
+    dataset: datasetFs,
+    config,
+    ...viewsDir ? { viewsDir } : {}
+  });
+  for (const file of result.files) {
+    await reportFs.writeFile(file.path, file.content);
+  }
+  process.stdout.write(
+    `report packs \u2192 ${result.files.length} files \xB7 ${result.bibliography} sources
+` + result.chapters.map((c) => `  ${c.id}: ${c.entryCount}`).join("\n") + "\n"
+  );
+  return 0;
+}
+async function runReportStitch(args) {
+  let reportRoot;
+  let configPath;
+  let out;
+  let chaptersDir;
+  let viewsDir;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--config":
+        configPath = next();
+        break;
+      case "--out":
+        out = next();
+        break;
+      case "--chapters-dir":
+        chaptersDir = next();
+        break;
+      case "--views-dir":
+        viewsDir = next();
+        break;
+      default:
+        if (!a.startsWith("-") && reportRoot === void 0) reportRoot = a;
+    }
+  }
+  const root = resolveWorkspacePath(reportRoot);
+  if (!configPath) {
+    return fail("report stitch needs --config <report.config.json>.", 2);
+  }
+  let config;
+  try {
+    config = loadReportConfig(configPath);
+  } catch (err) {
+    return fail(
+      `could not load/validate config "${configPath}": ${err instanceof Error ? err.message : String(err)}`,
+      2
+    );
+  }
+  const reportFs = new NodeFsAdapter({ root });
+  const { content, wordCount } = await stitchReport({
+    config,
+    report: reportFs,
+    ...chaptersDir ? { chaptersDir } : {},
+    ...viewsDir ? { viewsDir } : {}
+  });
+  await reportFs.writeFile(out ?? "REPORT.md", content);
+  process.stdout.write(`report stitch \u2192 ${out ?? "REPORT.md"} \xB7 ${wordCount} words
+`);
+  return 0;
+}
 var RPC_RESPONSE2 = z.object({ result: z.unknown().optional(), error: z.unknown().optional() }).loose();
 var RPC_MESSAGE = z.object({
   id: z.number().optional(),
@@ -2566,6 +2704,14 @@ Commands:
   knowledge [path] --tags a,b [--kind k --access scope --max n]
                                          Preview what a skill's knowledge: binding resolves to
                                          \u2014 refined entries + their provenance (filesystem).
+  report packs [dataset] --config <f> [--out <dir>] [--views-dir <n>]
+                                         Build per-chapter knowledge views + the global
+                                         citation bibliography from a dataset. Dataset is
+                                         mounted read-only; --out (default: dataset) is the
+                                         only writer; --views-dir defaults to "views".
+  report stitch [report] --config <f> [--out <REPORT.md>] [--chapters-dir <d> --views-dir <n>]
+                                         Stitch front + parts + chapters + annexes + Sources
+                                         into one REPORT.md (report-side reads only).
   sync [path] --config <sink.json> [--tags a,b --kind k --throttle ms]
                                          Push refined entries to an external store via a
                                          config-driven MCP sink (host-agnostic).
@@ -2605,6 +2751,8 @@ async function main(argv2) {
       return await runDistill(rest);
     case "knowledge":
       return await runKnowledge(rest);
+    case "report":
+      return await runReport(rest);
     case "sync":
       return await runSync(rest);
     default: