@bodhi-ventures/aiocs 0.3.1 → 0.5.0

package/dist/cli.js

@@ -2,56 +2,36 @@
 import {
   AIOCS_ERROR_CODES,
   AiocsError,
-  answerWorkspace,
   backfillEmbeddings,
-  bindWorkspaceSources,
   clearEmbeddings,
-  compileWorkspaceArtifacts,
-  createWorkspace,
   diffSnapshotsForSource,
   exportCatalogBackup,
   fetchSources,
-  generateWorkspaceArtifactOutput,
   getAiocsConfigDir,
   getAiocsDataDir,
   getDoctorReport,
   getEmbeddingStatus,
   getManagedSourceSpecDirectories,
-  getWorkspaceStatus,
   importCatalogBackup,
-  ingestWorkspaceRawInput,
   initManagedSources,
   linkProjectSources,
-  lintWorkspaceArtifacts,
   listSnapshotsForSource,
   listSources,
-  listWorkspaceArtifacts,
-  listWorkspaceRawInputsRecord,
-  listWorkspaceRecords,
   openCatalog,
   packageName,
   packageVersion,
   parseDaemonConfig,
   refreshDueSources,
-  removeWorkspaceRawInput,
   runEmbeddingWorker,
-  runQueuedWorkspaceCompiles,
   runSourceCanaries,
   searchCatalog,
-  searchWorkspaceCatalog,
-  searchWorkspaceRawInputCatalog,
   showChunk,
-  showWorkspaceArtifact,
-  showWorkspaceRawInput,
   startDaemon,
-  syncWorkspaceToObsidianVault,
   toAiocsError,
-  unbindWorkspaceSources,
   unlinkProjectSources,
-  updateWorkspaceSettings,
   upsertSourceFromSpecFile,
   verifyCoverage
-} from "./chunk-TJG2DPJU.js";
+} from "./chunk-6CY4TABN.js";
 
 // src/cli.ts
 import { Command, CommanderError as CommanderError2 } from "commander";
@@ -144,21 +124,6 @@ function renderSearchResult(result) {
     ""
   ].join("\n");
 }
-function renderWorkspaceSearchResult(result) {
-  if (result.kind === "source") {
-    return renderSearchResult(result);
-  }
-  return [
-    `Artifact: ${result.artifactPath}`,
-    `Kind: ${result.artifactKind}`,
-    `Section: ${result.sectionTitle}`,
-    `Stale: ${String(result.stale)}`,
-    `Score: ${result.score.toFixed(4)}`,
-    "",
-    result.markdown,
-    ""
-  ].join("\n");
-}
 function parsePositiveIntegerOption(value, field) {
   if (typeof value === "undefined") {
     return void 0;
@@ -280,7 +245,7 @@ function createDaemonLogger(json) {
   };
 }
 var program = new Command();
-program.name("docs").description("Local-only docs fetch and search CLI for AI agents.").option("-V, --version", "emit the current aiocs version").option("--json", "emit machine-readable JSON output").showHelpAfterError();
+program.name("aiocs").description("Local-only documentation fetch and search CLI for AI agents.").option("-V, --version", "emit the current aiocs version").option("--json", "emit machine-readable JSON output").showHelpAfterError();
 program.configureOutput({
   writeOut(output) {
     if (!argvWantsJson(process.argv)) {
@@ -475,309 +440,6 @@ project.command("unlink").argument("<project-path>").argument("[source-ids...]")
     };
   });
 });
-var workspace = program.command("workspace");
-workspace.command("create").argument("<workspace-id>").requiredOption("--label <label>", "workspace label").option("--purpose <purpose>", "workspace purpose/description").option("--auto-compile", "automatically recompile after bound-source or raw-input changes").option("--output <format>", "default output format", (value, current) => {
-  current.push(value);
-  return current;
-}, []).action(async (workspaceId, options, command) => {
-  await executeCommand(command, "workspace.create", async () => {
-    const result = await createWorkspace({
-      workspaceId,
-      label: options.label,
-      ...options.purpose ? { purpose: options.purpose } : {},
-      ...options.autoCompile ? { autoCompileEnabled: true } : {},
-      ...options.output && options.output.length > 0 ? { defaultOutputFormats: options.output } : {}
-    });
-    return {
-      data: result,
-      human: `Created workspace ${result.workspace.id}`
-    };
-  });
-});
-workspace.command("configure").argument("<workspace-id>").requiredOption("--auto-compile <enabled>", "set workspace auto-compile to true or false").action(async (workspaceId, options, command) => {
-  await executeCommand(command, "workspace.configure", async () => {
-    const normalized = options.autoCompile.trim().toLowerCase();
-    if (normalized !== "true" && normalized !== "false") {
-      throw new AiocsError(
-        AIOCS_ERROR_CODES.invalidArgument,
-        "--auto-compile must be true or false"
-      );
-    }
-    const result = await updateWorkspaceSettings({
-      workspaceId,
-      autoCompileEnabled: normalized === "true"
-    });
-    return {
-      data: result,
-      human: `Updated ${workspaceId}: autoCompile=${result.workspace.autoCompileEnabled}`
-    };
-  });
-});
-workspace.command("list").action(async (_options, command) => {
-  await executeCommand(command, "workspace.list", async () => {
-    const result = await listWorkspaceRecords();
-    return {
-      data: result,
-      human: result.workspaces.length === 0 ? "No workspaces registered." : result.workspaces.map((item) => [
-        item.id,
-        item.label,
-        `bindings=${item.bindingCount}`,
-        `artifacts=${item.artifactCount}`,
-        item.lastCompileStatus ? `last=${item.lastCompileStatus}` : "never compiled"
-      ].join(" | "))
-    };
-  });
-});
-workspace.command("bind").argument("<workspace-id>").argument("<source-ids...>").action(async (workspaceId, sourceIds, _options, command) => {
-  await executeCommand(command, "workspace.bind", async () => {
-    const result = await bindWorkspaceSources({ workspaceId, sourceIds });
-    return {
-      data: result,
-      human: `Bound ${workspaceId} -> ${sourceIds.join(", ")}`
-    };
-  });
-});
-workspace.command("unbind").argument("<workspace-id>").argument("[source-ids...]").action(async (workspaceId, sourceIds, _options, command) => {
-  await executeCommand(command, "workspace.unbind", async () => {
-    const result = await unbindWorkspaceSources({
-      workspaceId,
-      ...sourceIds.length > 0 ? { sourceIds } : {}
-    });
-    return {
-      data: result,
-      human: sourceIds.length > 0 ? `Unbound ${workspaceId} -> ${sourceIds.join(", ")}` : `Unbound all sources from ${workspaceId}`
-    };
-  });
-});
-workspace.command("compile").argument("<workspace-id>").action(async (workspaceId, _options, command) => {
-  await executeCommand(command, "workspace.compile", async () => {
-    const result = await compileWorkspaceArtifacts(workspaceId);
-    return {
-      data: result,
-      human: result.skipped ? `Workspace ${workspaceId} is already up to date.` : [
-        `Compiled ${workspaceId}`,
-        `Changed sources: ${result.changedSourceIds.join(", ") || "(none)"}`,
-        `Changed raw inputs: ${result.changedRawInputIds.join(", ") || "(none)"}`,
-        ...result.updatedArtifactPaths.map((path) => `- ${path}`)
-      ]
-    };
-  });
-});
-workspace.command("status").argument("<workspace-id>").action(async (workspaceId, _options, command) => {
-  await executeCommand(command, "workspace.status", async () => {
-    const result = await getWorkspaceStatus(workspaceId);
-    return {
-      data: result,
-      human: [
-        `${result.workspace.id} | ${result.workspace.label}`,
-        `Bindings=${result.bindings.length} | RawInputs=${result.rawInputs.length} | Artifacts=${result.artifacts.length} | Runs=${result.compileRuns.length}`,
-        `AutoCompile=${result.workspace.autoCompileEnabled} | Health=${result.health.status} | PendingJobs=${result.health.pendingCompileJobs} | FailedJobs=${result.health.failedCompileJobs}`,
-        `Links=${result.graph.linkCount} | BrokenLinks=${result.graph.brokenLinkCount} | Orphans=${result.graph.orphanArtifactCount}`
-      ]
-    };
-  });
-});
-workspace.command("queue-run").option("--max-jobs <count>", "maximum queued workspace compile jobs to process").action(async (options, command) => {
-  await executeCommand(command, "workspace.queue-run", async () => {
-    const maxJobs = parsePositiveIntegerOption(options.maxJobs, "max-jobs");
-    const result = await runQueuedWorkspaceCompiles({
-      ...typeof maxJobs === "number" ? { maxJobs } : {}
-    });
-    return {
-      data: result,
-      human: [
-        `Processed ${result.processedJobs} workspace compile job(s)`,
-        ...result.succeededJobs.map((job) => `success | ${job.workspaceId} | sources=${job.changedSourceIds.length} | raw=${job.changedRawInputIds.length}`),
-        ...result.failedJobs.map((job) => `failed | ${job.workspaceId} | ${job.errorMessage}`)
-      ]
-    };
-  });
-});
-workspace.command("search").argument("<workspace-id>").argument("<query>").option("--scope <scope>", "source, derived, or mixed").option("--mode <mode>", "search mode: auto, lexical, hybrid, semantic").option("--path <glob>", "restrict source-side search to file paths matching a glob", (value, current) => {
-  current.push(value);
-  return current;
-}, []).option("--language <name>", "restrict source-side search to a language", (value, current) => {
-  current.push(value);
-  return current;
-}, []).option("--limit <count>", "maximum number of results to return").option("--offset <count>", "number of results to skip before returning matches").action(async (workspaceId, query, options, command) => {
-  await executeCommand(command, "workspace.search", async () => {
-    const limit = parsePositiveIntegerOption(options.limit, "limit");
-    const offset = parsePositiveIntegerOption(options.offset, "offset");
-    const mode = parseSearchModeOption(options.mode);
-    const result = await searchWorkspaceCatalog(workspaceId, query, {
-      ...options.scope ? { scope: options.scope } : {},
-      ...mode ? { mode } : {},
-      ...options.path && options.path.length > 0 ? { path: options.path } : {},
-      ...options.language && options.language.length > 0 ? { language: options.language } : {},
-      ...typeof limit === "number" ? { limit } : {},
-      ...typeof offset === "number" ? { offset } : {}
-    });
-    return {
-      data: result,
-      human: result.results.length === 0 ? `No workspace results for "${query}" (${result.scope})` : [
-        `Showing ${result.offset + 1}-${result.offset + result.results.length} of ${result.total} workspace result(s)`,
-        ...result.results.map((entry) => renderWorkspaceSearchResult(entry))
-      ]
-    };
-  });
-});
-var workspaceArtifact = workspace.command("artifact");
-workspaceArtifact.command("list").argument("<workspace-id>").action(async (workspaceId, _options, command) => {
-  await executeCommand(command, "workspace.artifact.list", async () => {
-    const result = await listWorkspaceArtifacts(workspaceId);
-    return {
-      data: result,
-      human: result.artifacts.length === 0 ? `No artifacts for ${workspaceId}` : result.artifacts.map((artifact) => [
-        artifact.path,
-        artifact.kind,
-        artifact.stale ? "stale" : "fresh",
-        `chunks=${artifact.chunkCount}`
-      ].join(" | "))
-    };
-  });
-});
-workspaceArtifact.command("show").argument("<workspace-id>").argument("<artifact-path>").action(async (workspaceId, artifactPath, _options, command) => {
-  await executeCommand(command, "workspace.artifact.show", async () => {
-    const result = await showWorkspaceArtifact(workspaceId, artifactPath);
-    return {
-      data: result,
-      human: result.content
-    };
-  });
-});
-var workspaceIngest = workspace.command("ingest");
-workspaceIngest.command("add").argument("<workspace-id>").argument("<kind>").argument("<path>").option("--label <label>", "display label for the raw input").action(async (workspaceId, kind, path, options, command) => {
-  await executeCommand(command, "workspace.ingest.add", async () => {
-    const result = await ingestWorkspaceRawInput({
-      workspaceId,
-      kind,
-      sourcePath: path,
-      ...options.label ? { label: options.label } : {}
-    });
-    return {
-      data: result,
-      human: `Ingested ${result.rawInput.kind} ${result.rawInput.id} into ${workspaceId}`
-    };
-  });
-});
-workspaceIngest.command("list").argument("<workspace-id>").action(async (workspaceId, _options, command) => {
-  await executeCommand(command, "workspace.ingest.list", async () => {
-    const result = await listWorkspaceRawInputsRecord(workspaceId);
-    return {
-      data: result,
-      human: result.rawInputs.length === 0 ? `No raw inputs for ${workspaceId}` : result.rawInputs.map((rawInput) => [
-        rawInput.id,
-        rawInput.kind,
-        rawInput.label,
-        `chunks=${rawInput.chunkCount}`
-      ].join(" | "))
-    };
-  });
-});
-workspaceIngest.command("show").argument("<workspace-id>").argument("<raw-input-id>").action(async (workspaceId, rawInputId, _options, command) => {
-  await executeCommand(command, "workspace.ingest.show", async () => {
-    const result = await showWorkspaceRawInput(workspaceId, rawInputId);
-    return {
-      data: result,
-      human: [
-        `${result.rawInput.id} | ${result.rawInput.kind} | ${result.rawInput.label}`,
-        ...result.chunks.map((chunk) => `${chunk.section_title} | ${chunk.file_path ?? "(root)"}`)
-      ]
-    };
-  });
-});
-workspaceIngest.command("search").argument("<workspace-id>").argument("<query>").option("--kind <kind>", "raw input kind filter", (value, current) => {
-  current.push(value);
-  return current;
-}, []).option("--limit <count>", "maximum number of results to return").option("--offset <count>", "number of results to skip").action(async (workspaceId, query, options, command) => {
-  await executeCommand(command, "workspace.ingest.search", async () => {
-    const limit = parsePositiveIntegerOption(options.limit, "limit");
-    const offset = parsePositiveIntegerOption(options.offset, "offset");
-    const result = await searchWorkspaceRawInputCatalog({
-      workspaceId,
-      query,
-      ...options.kind && options.kind.length > 0 ? { kinds: options.kind } : {},
-      ...typeof limit === "number" ? { limit } : {},
-      ...typeof offset === "number" ? { offset } : {}
-    });
-    return {
-      data: result,
-      human: result.results.length === 0 ? `No raw-input matches for "${query}"` : [
-        `Showing ${result.offset + 1}-${result.offset + result.results.length} of ${result.total} raw-input result(s)`,
-        ...result.results.map((entry) => [
-          entry.rawInputId,
-          entry.kind,
-          entry.label,
-          entry.sectionTitle,
-          entry.filePath ?? "(root)"
-        ].join(" | "))
-      ]
-    };
-  });
-});
-workspaceIngest.command("remove").argument("<workspace-id>").argument("<raw-input-id>").action(async (workspaceId, rawInputId, _options, command) => {
-  await executeCommand(command, "workspace.ingest.remove", async () => {
-    const result = await removeWorkspaceRawInput({ workspaceId, rawInputId });
-    return {
-      data: result,
-      human: `Removed raw input ${rawInputId} from ${workspaceId}`
-    };
-  });
-});
-workspace.command("lint").argument("<workspace-id>").action(async (workspaceId, _options, command) => {
-  await executeCommand(command, "workspace.lint", async () => {
-    const result = await lintWorkspaceArtifacts(workspaceId);
-    return {
-      data: result,
-      human: [
-        `${workspaceId} lint status=${result.summary.status}`,
-        ...result.findings.map((finding) => `${finding.kind} | ${finding.artifactPath ?? finding.sourceId ?? "(workspace)"} | ${finding.summary}`)
-      ]
-    };
-  });
-});
-workspace.command("output").argument("<workspace-id>").argument("<format>").option("--name <name>", "output file slug").option("--prompt <prompt>", "extra output instructions").action(async (workspaceId, format, options, command) => {
-  await executeCommand(command, "workspace.output", async () => {
-    const result = await generateWorkspaceArtifactOutput({
-      workspaceId,
-      format,
-      ...options.name ? { name: options.name } : {},
-      ...options.prompt ? { prompt: options.prompt } : {}
-    });
-    return {
-      data: result,
-      human: `Generated ${result.format} at ${result.path}`
-    };
-  });
-});
-workspace.command("answer").argument("<workspace-id>").argument("<format>").argument("<question>").option("--name <name>", "output file slug").action(async (workspaceId, format, question, options, command) => {
-  await executeCommand(command, "workspace.answer", async () => {
-    const result = await answerWorkspace({
-      workspaceId,
-      format,
-      question,
-      ...options.name ? { name: options.name } : {}
-    });
-    return {
-      data: result,
-      human: `Answered into ${result.path} (${result.format})`
-    };
-  });
-});
-var workspaceSync = workspace.command("sync");
-workspaceSync.command("obsidian").argument("<workspace-id>").argument("<vault-path>").option("--export-subdir <subdir>", "vault subdirectory to sync into").action(async (workspaceId, vaultPath, options, command) => {
-  await executeCommand(command, "workspace.sync.obsidian", async () => {
-    const result = await syncWorkspaceToObsidianVault({
-      workspaceId,
-      vaultPath,
-      ...options.exportSubdir ? { exportSubdir: options.exportSubdir } : {}
-    });
-    return {
-      data: result,
-      human: `Synced ${workspaceId} to ${result.targetPath}`
-    };
-  });
-});
 var backup = program.command("backup");
 backup.command("export").argument("<output-dir>").option("--replace-existing", "replace an existing non-empty export directory").action(
   async (outputDir, options, command) => {