@pellux/goodvibes-agent 0.1.112 → 0.1.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.112",
+  "version": "0.1.114",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/persona-discovery.ts

@@ -0,0 +1,117 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type PersonaOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredPersonaRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: PersonaOrigin;
+  readonly body: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getPersonaDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: PersonaOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
+  ];
+}
+
+async function readPersonaFile(path: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const body = (frontmatter.system_prompt ?? markdownBody).trim();
+  if (!body) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'persona';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    body,
+    frontmatter,
+  };
+}
+
+async function scanPersonaDirectory(root: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredPersonaRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readPersonaFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readPersonaFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverPersonas(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredPersonaRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredPersonaRecord[] = [];
+
+  for (const { root, origin } of getPersonaDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanPersonaDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/agent/routine-discovery.ts

@@ -0,0 +1,115 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type RoutineOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredRoutineRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: RoutineOrigin;
+  readonly steps: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['ROUTINE.md', 'routine.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getRoutineDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: RoutineOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'routines'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'routines'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'global' },
+  ];
+}
+
+async function readRoutineFile(path: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const steps = (frontmatter.steps ?? markdownBody).trim();
+  if (!steps) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'routine';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    steps,
+    frontmatter,
+  };
+}
+
+async function scanRoutineDirectory(root: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredRoutineRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readRoutineFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readRoutineFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverRoutines(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredRoutineRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredRoutineRecord[] = [];
+
+  for (const { root, origin } of getRoutineDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanRoutineDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/cli/help.ts

@@ -165,6 +165,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     usage: [
       'personas list',
       'personas active',
+      'personas discover',
+      'personas import-discovered <name> [--use] --yes',
       'personas search <query>',
       'personas show <id>',
       'personas create --name <name> --description <summary> --body <instructions> [--tags a,b] [--triggers a,b] [--use]',
@@ -178,6 +180,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Manage Agent-local personas for the serial main conversation. Personas do not spawn worker agents.',
     examples: [
       'personas list',
+      'personas discover',
+      'personas import-discovered "Travel Planner" --use --yes',
       'personas create --name "Travel Planner" --description "Plan trips" --body "Compare options before booking" --use',
       'personas review travel-planner',
       'personas delete travel-planner --yes',
@@ -188,6 +192,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'skills list',
       'skills enabled',
       'skills active',
+      'skills discover',
+      'skills import-discovered <name> [--enabled] --yes',
       'skills search <query>',
       'skills show <id>',
       'skills create --name <name> --description <summary> --procedure <steps> [--tags a,b] [--triggers a,b] [--enabled]',
@@ -202,6 +208,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Manage reusable Agent-local procedures and skill bundles for the main conversation.',
     examples: [
       'skills list',
+      'skills discover',
+      'skills import-discovered "Daily Brief" --enabled --yes',
       'skills create --name "Daily Brief" --description "Summarize operator state" --procedure "Review Agent Knowledge, work plans, approvals, and routines" --enabled',
       'skills bundle create --name "Ops Pack" --description "Daily operations bundle" --skills daily-brief --enabled',
       'skills delete daily-brief --yes',
@@ -239,15 +247,19 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     usage: [
       'routines list',
       'routines enabled',
+      'routines discover',
+      'routines import-discovered <name> [--enabled] --yes',
       'routines show <id>',
       'routines receipts',
       'routines reconcile',
       'routines receipt <receipt-id>',
       'routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--delivery-channel <channel[:route[:label]]>|--delivery-route <route[:label]>|--delivery-webhook <url>|--delivery-link <url>] [--disabled] --yes',
     ],
-    summary: 'Inspect Agent-local routines, review local promotion receipts, reconcile receipts against live connected schedules, and explicitly promote a reviewed routine into a GoodVibes schedule. Without --yes, promote only prints the schedules.create preview.',
+    summary: 'Inspect and import Agent-local routines, review local promotion receipts, reconcile receipts against live connected schedules, and explicitly promote a reviewed routine into a GoodVibes schedule. Without --yes, promote only prints the schedules.create preview.',
     examples: [
       'routines list',
+      'routines discover',
+      'routines import-discovered "Daily Brief" --enabled --yes',
       'routines show daily-operations-sweep',
       'routines receipts',
       'routines reconcile',

package/src/cli/local-library-command.ts

@@ -1,5 +1,7 @@
 import { createShellPathService } from '@/runtime/index.ts';
+import { discoverPersonas, type DiscoveredPersonaRecord } from '../agent/persona-discovery.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
+import { discoverSkills, type SkillRecord } from '../agent/skill-discovery.ts';
 import {
   AgentSkillRegistry,
   type AgentSkillBundleRecord,
@@ -107,6 +109,13 @@ function skillRegistry(runtime: CliCommandRuntime): AgentSkillRegistry {
   }));
 }
 
+function shellPaths(runtime: CliCommandRuntime): ReturnType<typeof createShellPathService> {
+  return createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+}
+
 function summarizePersona(persona: AgentPersonaRecord, activePersonaId: string | null): string {
   const active = persona.id === activePersonaId ? 'active' : 'available';
   const tags = persona.tags.length > 0 ? ` tags=${persona.tags.join(',')}` : '';
@@ -148,6 +157,50 @@ function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | nu
   ].filter((line): line is string => Boolean(line)).join('\n');
 }
 
+function summarizeDiscoveredPersona(persona: DiscoveredPersonaRecord): string {
+  const description = persona.description ? ` - ${persona.description}` : '';
+  return [
+    `  ${persona.name}  ${persona.origin}${description}`,
+    `    path: ${persona.path}`,
+  ].join('\n');
+}
+
+function renderDiscoveredPersonaList(personas: readonly DiscoveredPersonaRecord[]): string {
+  if (personas.length === 0) {
+    return [
+      'Discovered Agent persona files',
+      '  No persona markdown files found in Agent persona folders.',
+      '  Search roots: .goodvibes/personas, .goodvibes/agent/personas, .goodvibes/agents, ~/.goodvibes/personas, ~/.goodvibes/agent/personas, ~/.goodvibes/agents',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent persona files (${personas.length})`,
+    ...personas.map(summarizeDiscoveredPersona),
+    '',
+    'Import one with: goodvibes-agent personas import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredPersonaLookupValues(persona: DiscoveredPersonaRecord): readonly string[] {
+  const slug = persona.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = persona.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [persona.name, slug, persona.path, basename]
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findDiscoveredPersona(personas: readonly DiscoveredPersonaRecord[], idOrName: string): DiscoveredPersonaRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return personas.find((persona) => discoveredPersonaLookupValues(persona).includes(lookup)) ?? null;
+}
+
+function discoveredPersonaFrontmatterList(persona: DiscoveredPersonaRecord, key: string): readonly string[] {
+  const value = persona.frontmatter[key];
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function summarizeSkill(skill: AgentSkillRecord): string {
   const enabled = skill.enabled ? 'enabled' : 'disabled';
   const tags = skill.tags.length > 0 ? ` tags=${skill.tags.join(',')}` : '';
@@ -174,6 +227,52 @@ function renderSkillList(title: string, path: string, skills: readonly AgentSkil
   ].join('\n');
 }
 
+function summarizeDiscoveredSkill(skill: SkillRecord): string {
+  const description = skill.description ? ` - ${skill.description}` : '';
+  const dependencies = skill.dependencies.length > 0 ? ` deps=${skill.dependencies.join(',')}` : '';
+  const includes = skill.includes.length > 0 ? ` includes=${skill.includes.join(',')}` : '';
+  return [
+    `  ${skill.name}  ${skill.origin}${description}${dependencies}${includes}`,
+    `    path: ${skill.path}`,
+  ].join('\n');
+}
+
+function renderDiscoveredSkillList(skills: readonly SkillRecord[]): string {
+  if (skills.length === 0) {
+    return [
+      'Discovered Agent skill files',
+      '  No SKILL.md or .md skill files found in Agent skill folders.',
+      '  Search roots: .goodvibes/skills, .goodvibes/agent/skills, ~/.goodvibes/skills, ~/.goodvibes/agent/skills',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent skill files (${skills.length})`,
+    ...skills.map(summarizeDiscoveredSkill),
+    '',
+    'Import one with: goodvibes-agent skills import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredSkillLookupValues(skill: SkillRecord): readonly string[] {
+  const slug = skill.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = skill.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [skill.name, slug, skill.path, basename]
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findDiscoveredSkill(skills: readonly SkillRecord[], idOrName: string): SkillRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return skills.find((skill) => discoveredSkillLookupValues(skill).includes(lookup)) ?? null;
+}
+
+function discoveredFrontmatterList(skill: SkillRecord, key: string): readonly string[] {
+  const value = skill.frontmatter[key];
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function renderBundleList(title: string, path: string, bundles: readonly AgentSkillBundleRecord[]): string {
   if (bundles.length === 0) {
     return [
@@ -227,11 +326,11 @@ function renderBundle(bundle: AgentSkillBundleRecord): string {
 }
 
 function usagePersonas(): string {
-  return 'Usage: goodvibes-agent personas [list|active|search <query>|show <id>|create|update <id>|use <id>|clear|review <id>|stale <id> <reason>|delete <id> --yes]';
+  return 'Usage: goodvibes-agent personas [list|active|discover|import-discovered <name> --yes|search <query>|show <id>|create|update <id>|use <id>|clear|review <id>|stale <id> <reason>|delete <id> --yes]';
 }
 
 function usageSkills(): string {
-  return 'Usage: goodvibes-agent skills [list|enabled|active|search <query>|show <id>|create|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes|bundle ...]';
+  return 'Usage: goodvibes-agent skills [list|enabled|active|discover|import-discovered <name> --yes|search <query>|show <id>|create|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes|bundle ...]';
 }
 
 function usageBundles(): string {
@@ -258,6 +357,41 @@ export async function handlePersonasCommand(runtime: CliCommandRuntime): Promise
       if (!active) return failure(runtime, 'agent.personas.active_missing', 'No active Agent persona.', 1);
       return success(runtime, 'agent.personas.active', active, renderPersona(active, active.id));
     }
+    if (normalized === 'discover') {
+      const discovered = await discoverPersonas(shellPaths(runtime));
+      return success(runtime, 'agent.personas.discover', { personas: discovered }, renderDiscoveredPersonaList(discovered));
+    }
+    if (normalized === 'import-discovered' || normalized === 'import-persona') {
+      const options = parseOptions(rest);
+      const name = options.positionals.join(' ').trim();
+      if (!name) return failure(runtime, 'invalid_persona_command', 'Usage: goodvibes-agent personas import-discovered <name> [--use] --yes', 2);
+      const discovered = findDiscoveredPersona(await discoverPersonas(shellPaths(runtime)), name);
+      if (!discovered) {
+        return failure(runtime, 'persona_discovery_not_found', `Unknown discovered Agent persona: ${name}\nRun goodvibes-agent personas discover to inspect available persona files.`, 1);
+      }
+      if (!hasFlag(options, 'yes')) {
+        return success(runtime, 'agent.personas.import_discovered.preview', { persona: discovered }, [
+          'Agent persona import preview',
+          `  name: ${discovered.name}`,
+          `  origin: ${discovered.origin}`,
+          `  path: ${discovered.path}`,
+          `  description: ${discovered.description || '(none)'}`,
+          `  body characters: ${discovered.body.length}`,
+          '  next: rerun with --yes to import into the Agent-local persona registry',
+        ].join('\n'));
+      }
+      const persona = registry.create({
+        name: discovered.name,
+        description: discovered.description || `Imported persona from ${discovered.origin} markdown file.`,
+        body: discovered.body,
+        tags: discoveredPersonaFrontmatterList(discovered, 'tags'),
+        triggers: discoveredPersonaFrontmatterList(discovered, 'triggers'),
+        source: 'imported',
+        provenance: `discovered:${discovered.origin}:${discovered.path}`,
+      });
+      if (hasFlag(options, 'use')) registry.setActive(persona.id);
+      return success(runtime, 'agent.personas.import_discovered', persona, `Imported Agent persona ${persona.id}: ${persona.name}${hasFlag(options, 'use') ? ' (active)' : ''}`);
+    }
     if (normalized === 'search' || normalized === 'find') {
       const query = rest.join(' ').trim();
       const results = registry.search(query);
@@ -453,6 +587,41 @@ export async function handleSkillsCommand(runtime: CliCommandRuntime): Promise<C
         snapshot.enabledBundles.length > 0 ? renderBundleList('Enabled Agent skill bundles', snapshot.path, snapshot.enabledBundles) : '',
       ].filter(Boolean).join('\n\n'));
     }
+    if (normalized === 'discover') {
+      const discovered = await discoverSkills(shellPaths(runtime));
+      return success(runtime, 'agent.skills.discover', { skills: discovered }, renderDiscoveredSkillList(discovered));
+    }
+    if (normalized === 'import-discovered' || normalized === 'import-skill') {
+      const options = parseOptions(rest);
+      const name = options.positionals.join(' ').trim();
+      if (!name) return failure(runtime, 'invalid_skill_command', 'Usage: goodvibes-agent skills import-discovered <name> [--enabled] --yes', 2);
+      const discovered = findDiscoveredSkill(await discoverSkills(shellPaths(runtime)), name);
+      if (!discovered) {
+        return failure(runtime, 'skill_discovery_not_found', `Unknown discovered Agent skill: ${name}\nRun goodvibes-agent skills discover to inspect available skill files.`, 1);
+      }
+      if (!hasFlag(options, 'yes')) {
+        return success(runtime, 'agent.skills.import_discovered.preview', { skill: discovered }, [
+          'Agent skill import preview',
+          `  name: ${discovered.name}`,
+          `  origin: ${discovered.origin}`,
+          `  path: ${discovered.path}`,
+          `  description: ${discovered.description || '(none)'}`,
+          `  procedure characters: ${discovered.body.length}`,
+          '  next: rerun with --yes to import into the Agent-local skill registry',
+        ].join('\n'));
+      }
+      const skill = registry.create({
+        name: discovered.name,
+        description: discovered.description || `Imported skill from ${discovered.origin} skill file.`,
+        procedure: discovered.body,
+        tags: discoveredFrontmatterList(discovered, 'tags'),
+        triggers: discoveredFrontmatterList(discovered, 'triggers'),
+        enabled: hasFlag(options, 'enabled'),
+        source: 'imported',
+        provenance: `discovered:${discovered.origin}:${discovered.path}`,
+      });
+      return success(runtime, 'agent.skills.import_discovered', skill, `Imported Agent skill ${skill.id}: ${skill.name}${skill.enabled ? ' (enabled)' : ''}`);
+    }
     if (normalized === 'search' || normalized === 'find') {
       const query = rest.join(' ').trim();
       const results = registry.search(query);