gyrus 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gyrus",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Model-agnostic knowledge management CLI with MCP server support",
   "type": "module",
   "bin": {

package/src/commands/skill.ts

@@ -0,0 +1,432 @@
+/**
+ * Skill CLI Command
+ * Handles all skill-related CLI operations
+ *
+ * Usage:
+ *   gyrus skill list [--workspace <name>] [--tags <t1,t2>]
+ *   gyrus skill read <name> [--workspace <name>]
+ *   gyrus skill search <query> [--workspace <name>] [--tags <t1,t2>] [--trigger <t>]
+ *   gyrus skill create <name> --title <title> --content <content> [options]
+ *   gyrus skill update <name> [--title <title>] [--content <content>] [--tags <t1,t2>]
+ *
+ * Aliases: gyrus s
+ */
+
+import { readConfig } from "../config/index.ts";
+import { WorkspaceManager } from "../services/workspace.ts";
+import {
+  listSkills,
+  readSkill,
+  searchSkills,
+  createSkill,
+  updateSkill,
+} from "../operations/skill.ts";
+import {
+  formatSkillListCli,
+  formatSkillReadCli,
+  formatSkillSearchCli,
+  formatSkillCreateCli,
+  formatSkillUpdateCli,
+} from "../formatters/skill.ts";
+
+const HELP = `
+Usage: gyrus skill <subcommand> [options]
+
+Subcommands:
+  list                     List all skills
+  read <name>              Read a specific skill by name
+  search <query>           Search skills by text query
+  create                   Create a new skill (with flags)
+  update <name>            Update an existing skill
+
+Global Options:
+  -w, --workspace <name>   Target workspace (default: active workspace)
+  -h, --help               Show this help message
+
+List Options:
+  -t, --tags <t1,t2,...>   Filter by tags (comma-separated)
+
+Search Options:
+  -t, --tags <t1,t2,...>   Filter by tags
+  --trigger <trigger>      Filter by trigger pattern
+
+Create Options (name and title required):
+  --name <name>            Skill name in kebab-case
+  --title <title>          Skill title
+  --content <content>      Skill content (or use --file)
+  --file <path>            Read content from file
+  -t, --tags <t1,t2,...>   Tags (comma-separated)
+  --triggers <t1,t2,...>   Trigger patterns (comma-separated)
+  --apply-to <a1,a2,...>   Apply to file patterns (comma-separated)
+  --related <id1,id2,...>  Related skill names
+  --description <desc>     Brief description
+
+Update Options:
+  --title <title>          New title
+  --content <content>      New content (or use --file)
+  --file <path>            Read content from file
+  -t, --tags <t1,t2,...>   New tags (replaces existing)
+  --triggers <t1,t2,...>   New triggers (replaces existing)
+  --apply-to <a1,a2,...>   New apply-to patterns (replaces existing)
+  --related <id1,id2,...>  New related names (replaces existing)
+  --description <desc>     New description
+
+Examples:
+  gyrus skill list
+  gyrus skill list --tags typescript,testing
+  gyrus skill read code-review
+  gyrus skill search "testing" --tags quality
+  gyrus skill create --name code-review --title "Code Review Guide" --content "# Code Review..."
+  gyrus s list -w work
+
+Aliases: s
+`;
+
+/**
+ * Parse command-line arguments into options object
+ */
+function parseArgs(args: string[]): {
+  subcommand: string;
+  positional: string[];
+  options: Record<string, string | boolean>;
+} {
+  const options: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+  let subcommand = "";
+
+  let i = 0;
+
+  // First non-flag argument is the subcommand
+  while (i < args.length && !subcommand) {
+    if (!args[i].startsWith("-")) {
+      subcommand = args[i];
+      i++;
+      break;
+    }
+    i++;
+  }
+
+  // Parse remaining arguments
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      i++;
+    } else if (arg === "-w" || arg === "--workspace") {
+      options.workspace = args[++i] || "";
+      i++;
+    } else if (arg === "-t" || arg === "--tags") {
+      options.tags = args[++i] || "";
+      i++;
+    } else if (arg === "--name") {
+      options.name = args[++i] || "";
+      i++;
+    } else if (arg === "--title") {
+      options.title = args[++i] || "";
+      i++;
+    } else if (arg === "--content") {
+      options.content = args[++i] || "";
+      i++;
+    } else if (arg === "--file") {
+      options.file = args[++i] || "";
+      i++;
+    } else if (arg === "--triggers") {
+      options.triggers = args[++i] || "";
+      i++;
+    } else if (arg === "--trigger") {
+      options.trigger = args[++i] || "";
+      i++;
+    } else if (arg === "--apply-to") {
+      options.applyTo = args[++i] || "";
+      i++;
+    } else if (arg === "--related") {
+      options.related = args[++i] || "";
+      i++;
+    } else if (arg === "--description") {
+      options.description = args[++i] || "";
+      i++;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+      i++;
+    } else {
+      // Unknown flag, skip
+      i++;
+    }
+  }
+
+  return { subcommand, positional, options };
+}
+
+/**
+ * Parse comma-separated string into array
+ */
+function parseList(value: string | undefined): string[] | undefined {
+  if (!value || typeof value !== "string") return undefined;
+  return value
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Read content from file if --file option is provided
+ */
+async function getContent(
+  options: Record<string, string | boolean>,
+): Promise<string | undefined> {
+  if (options.file && typeof options.file === "string") {
+    try {
+      const file = Bun.file(options.file);
+      return await file.text();
+    } catch (error) {
+      console.error(`Error reading file: ${options.file}`);
+      process.exit(1);
+    }
+  }
+  return typeof options.content === "string" ? options.content : undefined;
+}
+
+/**
+ * Handle the list subcommand
+ */
+async function handleList(
+  manager: WorkspaceManager,
+  options: Record<string, string | boolean>,
+): Promise<void> {
+  const result = await listSkills(manager, {
+    workspace:
+      typeof options.workspace === "string" ? options.workspace : undefined,
+    tags: parseList(options.tags as string),
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatSkillListCli(result.data!));
+}
+
+/**
+ * Handle the read subcommand
+ */
+async function handleRead(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>,
+): Promise<void> {
+  const name = positional[0];
+
+  if (!name) {
+    console.error("Error: Please provide a skill name");
+    console.error("Usage: gyrus skill read <name>");
+    process.exit(1);
+  }
+
+  const result = await readSkill(manager, {
+    workspace:
+      typeof options.workspace === "string" ? options.workspace : undefined,
+    name,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatSkillReadCli(result.data!));
+}
+
+/**
+ * Handle the search subcommand
+ */
+async function handleSearch(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>,
+): Promise<void> {
+  const query = positional[0];
+  const tags = parseList(options.tags as string);
+  const trigger =
+    typeof options.trigger === "string" ? options.trigger : undefined;
+
+  if (!query && !tags?.length && !trigger) {
+    console.error("Error: Please provide a search query, tags, or trigger");
+    console.error(
+      "Usage: gyrus skill search <query> [--tags <t1,t2>] [--trigger <t>]",
+    );
+    process.exit(1);
+  }
+
+  const result = await searchSkills(manager, {
+    workspace:
+      typeof options.workspace === "string" ? options.workspace : undefined,
+    query,
+    tags,
+    trigger,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatSkillSearchCli(result.data!));
+}
+
+/**
+ * Handle the create subcommand
+ */
+async function handleCreate(
+  manager: WorkspaceManager,
+  options: Record<string, string | boolean>,
+): Promise<void> {
+  const name = typeof options.name === "string" ? options.name : undefined;
+  const title = typeof options.title === "string" ? options.title : undefined;
+  const content = await getContent(options);
+
+  if (!name || !title || !content) {
+    console.error("Error: Missing required options for create");
+    console.error("Required: --name, --title, --content (or --file)");
+    console.error("\nExample:");
+    console.error(
+      '  gyrus skill create --name code-review --title "Code Review Guide" --content "# Instructions..."',
+    );
+    process.exit(1);
+  }
+
+  const result = await createSkill(manager, {
+    workspace:
+      typeof options.workspace === "string" ? options.workspace : undefined,
+    name,
+    title,
+    content,
+    description:
+      typeof options.description === "string" ? options.description : undefined,
+    tags: parseList(options.tags as string),
+    triggers: parseList(options.triggers as string),
+    applyTo: parseList(options.applyTo as string),
+    related: parseList(options.related as string),
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatSkillCreateCli(result.data!));
+}
+
+/**
+ * Handle the update subcommand
+ */
+async function handleUpdate(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>,
+): Promise<void> {
+  const name = positional[0];
+
+  if (!name) {
+    console.error("Error: Please provide a skill name to update");
+    console.error("Usage: gyrus skill update <name> [options]");
+    process.exit(1);
+  }
+
+  const content = await getContent(options);
+  const hasUpdates =
+    options.title ||
+    content ||
+    options.tags ||
+    options.triggers ||
+    options.applyTo ||
+    options.related ||
+    options.description;
+
+  if (!hasUpdates) {
+    console.error("Error: No update options provided");
+    console.error(
+      "Available options: --title, --content, --file, --tags, --triggers, --apply-to, --related, --description",
+    );
+    process.exit(1);
+  }
+
+  const result = await updateSkill(manager, {
+    workspace:
+      typeof options.workspace === "string" ? options.workspace : undefined,
+    name,
+    title: typeof options.title === "string" ? options.title : undefined,
+    content,
+    description:
+      typeof options.description === "string" ? options.description : undefined,
+    tags: parseList(options.tags as string),
+    triggers: parseList(options.triggers as string),
+    applyTo: parseList(options.applyTo as string),
+    related: parseList(options.related as string),
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatSkillUpdateCli(result.data!));
+}
+
+/**
+ * Main skill command handler
+ */
+export async function skillCommand(args: string[]): Promise<void> {
+  const { subcommand, positional, options } = parseArgs(args);
+
+  // Show help if requested or no subcommand
+  if (options.help || !subcommand) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  // Load config and create workspace manager
+  const config = readConfig();
+  if (!config) {
+    console.error("Error: No configuration found. Run `gyrus init` first.");
+    process.exit(1);
+  }
+
+  const manager = new WorkspaceManager(config);
+
+  // Route to subcommand handler
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      await handleList(manager, options);
+      break;
+
+    case "read":
+    case "get":
+    case "show":
+      await handleRead(manager, positional, options);
+      break;
+
+    case "search":
+    case "find":
+      await handleSearch(manager, positional, options);
+      break;
+
+    case "create":
+    case "new":
+    case "add":
+      await handleCreate(manager, options);
+      break;
+
+    case "update":
+    case "edit":
+      await handleUpdate(manager, positional, options);
+      break;
+
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.log("\nRun `gyrus skill --help` for usage information.");
+      process.exit(1);
+  }
+}

package/src/config/index.ts

@@ -131,7 +131,10 @@ export function getOrCreateConfig(): GyrusConfig {
 /**
  * Get a workspace by name
  */
-export function getWorkspace(config: GyrusConfig, name: string): Workspace | null {
+export function getWorkspace(
+  config: GyrusConfig,
+  name: string,
+): Workspace | null {
   return config.workspaces.find((ws) => ws.name === name) ?? null;
 }
 
@@ -148,7 +151,7 @@ export function getDefaultWorkspace(config: GyrusConfig): Workspace | null {
  */
 export function addWorkspace(
   config: GyrusConfig,
-  workspace: Workspace
+  workspace: Workspace,
 ): string | null {
   // Validate name format
   if (!isValidWorkspaceName(workspace.name)) {
@@ -162,9 +165,7 @@ export function addWorkspace(
 
   // Check for duplicate path
   const expandedPath = expandPath(workspace.path);
-  if (
-    config.workspaces.some((ws) => expandPath(ws.path) === expandedPath)
-  ) {
+  if (config.workspaces.some((ws) => expandPath(ws.path) === expandedPath)) {
     return `A workspace already exists at "${workspace.path}".`;
   }
 
@@ -178,7 +179,7 @@ export function addWorkspace(
  */
 export function removeWorkspace(
   config: GyrusConfig,
-  name: string
+  name: string,
 ): string | null {
   const index = config.workspaces.findIndex((ws) => ws.name === name);
 
@@ -207,7 +208,7 @@ export function removeWorkspace(
  */
 export function setDefaultWorkspace(
   config: GyrusConfig,
-  name: string
+  name: string,
 ): string | null {
   if (!config.workspaces.some((ws) => ws.name === name)) {
     return `Workspace "${name}" not found.`;
@@ -224,12 +225,14 @@ export function getWorkspacePaths(workspace: Workspace): {
   root: string;
   knowledge: string;
   adrs: string;
+  skills: string;
 } {
   const root = expandPath(workspace.path);
   return {
     root,
     knowledge: join(root, "knowledge"),
     adrs: join(root, "adrs"),
+    skills: join(root, "skills"),
   };
 }