@bodhi-ventures/aiocs 0.2.0 → 0.3.0

package/dist/cli.js

@@ -2,36 +2,56 @@
 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-M7YEYMJL.js";
+} from "./chunk-GX6CZOO7.js";
 
 // src/cli.ts
 import { Command, CommanderError as CommanderError2 } from "commander";
@@ -124,6 +144,21 @@ 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;
@@ -440,6 +475,309 @@ 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) => {