@pellux/goodvibes-agent 0.1.113 → 0.1.116

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

@@ -1,4 +1,5 @@
 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 {
@@ -156,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(',')}` : '';
@@ -281,7 +326,7 @@ 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 {
@@ -312,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);

package/src/cli/profiles-command.ts

@@ -1,5 +1,7 @@
 import {
   createAgentRuntimeProfile,
+  createAgentRuntimeProfileFromDiscovered,
+  createAgentRuntimeProfileTemplateFromDiscovered,
   deleteAgentRuntimeProfile,
   exportAgentRuntimeProfileTemplate,
   importAgentRuntimeProfileTemplate,
@@ -16,6 +18,7 @@ import type { CliCommandOutput, GoodVibesCliParseResult } from './types.ts';
 interface ProfilesCommandRuntime {
   readonly cli: GoodVibesCliParseResult;
   readonly homeDirectory: string;
+  readonly workingDirectory: string;
 }
 
 function hasYes(args: readonly string[]): boolean {
@@ -53,6 +56,12 @@ function parseTemplate(args: readonly string[]): AgentRuntimeProfileTemplateId |
   throw new Error(`Unknown Agent starter profile template: ${raw}. Use profiles templates to list starters.`);
 }
 
+function parseCsvFlag(args: readonly string[], names: readonly string[]): readonly string[] | undefined {
+  const raw = flagValue(args, names);
+  if (!raw) return undefined;
+  return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function profileLine(profile: AgentRuntimeProfileInfo): string {
   const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
   const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
@@ -99,6 +108,27 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
       `  use: goodvibes-agent profiles create <name> --template ${result.data.template.id} --yes`,
     ].join('\n');
   }
+  if (result.kind === 'agent.profiles.template.from_discovered' && result.data?.template) {
+    return [
+      `Agent starter template created from discovered behavior: ${result.data.template.id}`,
+      `  name: ${result.data.template.name}`,
+      `  persona: ${result.data.template.personaName}`,
+      `  skills: ${result.data.template.skillNames.join(', ')}`,
+      `  routines: ${result.data.template.routineNames.join(', ')}`,
+      `  use: goodvibes-agent profiles create <name> --template ${result.data.template.id} --yes`,
+    ].join('\n');
+  }
+  if (result.kind === 'agent.profiles.create_from_discovered' && result.data?.profile && result.data.template) {
+    return [
+      `Agent profile created from discovered behavior: ${result.data.profile.id}`,
+      `  home: ${result.data.profile.homeDirectory}`,
+      `  starter: ${result.data.template.id}`,
+      `  persona: ${result.data.template.personaName}`,
+      `  skills: ${result.data.template.skillNames.join(', ')}`,
+      `  routines: ${result.data.template.routineNames.join(', ')}`,
+      `  launch: ${result.data.nextCommand ?? `goodvibes-agent --agent-profile ${result.data.profile.id}`}`,
+    ].join('\n');
+  }
   const profile = result.data?.profile;
   if (result.kind === 'agent.profiles.create' && profile) {
     const template = result.data?.appliedTemplate;
@@ -142,6 +172,51 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
 
     if (sub === 'templates' || sub === 'starters') {
       const [templateAction, templateId, templatePath] = values;
+      if (templateAction === 'from-discovered' || templateAction === 'import-discovered') {
+        if (!templateId) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: 'Usage: goodvibes-agent profiles templates from-discovered <id> [--name <name>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --yes',
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        if (!hasYes(rawRest)) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: `Refusing to create Agent starter template ${templateId} from discovered behavior without --yes.`,
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        const template = await createAgentRuntimeProfileTemplateFromDiscovered({
+          homeDirectory: runtime.homeDirectory,
+          workingDirectory: runtime.workingDirectory,
+        }, {
+          id: templateId,
+          name: flagValue(rawRest, ['--name']) ?? undefined,
+          description: flagValue(rawRest, ['--description']) ?? undefined,
+          persona: flagValue(rawRest, ['--persona']) ?? undefined,
+          skills: parseCsvFlag(rawRest, ['--skills']),
+          routines: parseCsvFlag(rawRest, ['--routines']),
+          replace: hasYes(rawRest) && rawRest.includes('--replace'),
+        });
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.template.from_discovered',
+          data: { template },
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
       if (templateAction === 'export') {
         if (!templateId || !templatePath) {
           const result: AgentRuntimeProfileCommandResult = {
@@ -290,6 +365,59 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
       };
     }
 
+    if (sub === 'create-from-discovered' || sub === 'create-discovered') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles create-from-discovered <name> [--template-id <id>] [--profile-name <display>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --yes',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      if (!hasYes(rawRest)) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: `Refusing to create Agent profile ${name} from discovered behavior without --yes.`,
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const created = await createAgentRuntimeProfileFromDiscovered({
+        homeDirectory: runtime.homeDirectory,
+        workingDirectory: runtime.workingDirectory,
+      }, {
+        profileName: name,
+        templateId: flagValue(rawRest, ['--template-id', '--starter-id']) ?? undefined,
+        name: flagValue(rawRest, ['--profile-name', '--name']) ?? undefined,
+        description: flagValue(rawRest, ['--description']) ?? undefined,
+        persona: flagValue(rawRest, ['--persona']) ?? undefined,
+        skills: parseCsvFlag(rawRest, ['--skills']),
+        routines: parseCsvFlag(rawRest, ['--routines']),
+        replace: rawRest.includes('--replace'),
+      });
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.create_from_discovered',
+        data: {
+          profile: created.profile,
+          appliedTemplate: created.profile.starterTemplateApplication,
+          template: created.template,
+          nextCommand: `goodvibes-agent --agent-profile ${created.profile.id}`,
+        },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
     if (sub === 'delete' || sub === 'remove') {
       const name = values[0];
       if (!name) {

package/src/cli/routines-command.ts

@@ -1,4 +1,5 @@
 import { createShellPathService } from '@/runtime/index.ts';
+import { discoverRoutines, type DiscoveredRoutineRecord } from '../agent/routine-discovery.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
@@ -44,6 +45,13 @@ function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
   }));
 }
 
+function shellPaths(runtime: CliCommandRuntime): ReturnType<typeof createShellPathService> {
+  return createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+}
+
 function routineReceiptStore(runtime: CliCommandRuntime): RoutineScheduleReceiptStore {
   return RoutineScheduleReceiptStore.fromShellPaths(createShellPathService({
     workingDirectory: runtime.workingDirectory,
@@ -51,12 +59,83 @@ function routineReceiptStore(runtime: CliCommandRuntime): RoutineScheduleReceipt
   }));
 }
 
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function parseImportFlags(args: readonly string[]): {
+  readonly name: string;
+  readonly enabled: boolean;
+  readonly yes: boolean;
+} {
+  const positionals: string[] = [];
+  let enabled = false;
+  let yes = false;
+  for (const arg of args) {
+    if (arg === '--enabled') {
+      enabled = true;
+      continue;
+    }
+    if (arg === '--yes') {
+      yes = true;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return { name: positionals.join(' ').trim(), enabled, yes };
+}
+
 function summarizeRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
   const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
   return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
 }
 
+function summarizeDiscoveredRoutine(routine: DiscoveredRoutineRecord): string {
+  const description = routine.description ? ` - ${routine.description}` : '';
+  return [
+    `  ${routine.name}  ${routine.origin}${description}`,
+    `    path: ${routine.path}`,
+  ].join('\n');
+}
+
+function renderDiscoveredRoutineList(routines: readonly DiscoveredRoutineRecord[]): string {
+  if (routines.length === 0) {
+    return [
+      'Discovered Agent routine files',
+      '  No routine markdown files found in Agent routine folders.',
+      '  Search roots: .goodvibes/routines, .goodvibes/agent/routines, ~/.goodvibes/routines, ~/.goodvibes/agent/routines',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent routine files (${routines.length})`,
+    ...routines.map(summarizeDiscoveredRoutine),
+    '',
+    'Import one with: goodvibes-agent routines import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredRoutineLookupValues(routine: DiscoveredRoutineRecord): readonly string[] {
+  const slug = routine.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = routine.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [routine.name, slug, routine.path, basename]
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findDiscoveredRoutine(routines: readonly DiscoveredRoutineRecord[], idOrName: string): DiscoveredRoutineRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return routines.find((routine) => discoveredRoutineLookupValues(routine).includes(lookup)) ?? null;
+}
+
+function discoveredRoutineFrontmatterList(routine: DiscoveredRoutineRecord, key: string): readonly string[] {
+  const value = routine.frontmatter[key];
+  if (!value) return [];
+  return splitList(value);
+}
+
 function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[]): string {
   if (routines.length === 0) {
     return [
@@ -176,6 +255,82 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       exitCode: 0,
     };
   }
+  if (normalized === 'discover') {
+    const discovered = await discoverRoutines(shellPaths(runtime));
+    const value: RoutinesCommandSuccess<{ readonly routines: readonly DiscoveredRoutineRecord[] }> = {
+      ok: true,
+      kind: 'agent.routines.discover',
+      data: { routines: discovered },
+    };
+    return {
+      output: jsonOrText(runtime, value, renderDiscoveredRoutineList(discovered)),
+      exitCode: 0,
+    };
+  }
+  if (normalized === 'import-discovered' || normalized === 'import-routine') {
+    const parsed = parseImportFlags(rest);
+    if (!parsed.name) {
+      const failure: RoutinesCommandFailure = {
+        ok: false,
+        kind: 'invalid_routine_command',
+        error: 'Usage: goodvibes-agent routines import-discovered <name> [--enabled] --yes',
+      };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 2,
+      };
+    }
+    const discovered = findDiscoveredRoutine(await discoverRoutines(shellPaths(runtime)), parsed.name);
+    if (!discovered) {
+      const failure: RoutinesCommandFailure = {
+        ok: false,
+        kind: 'routine_discovery_not_found',
+        error: `Unknown discovered Agent routine: ${parsed.name}\nRun goodvibes-agent routines discover to inspect available routine files.`,
+      };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 1,
+      };
+    }
+    if (!parsed.yes) {
+      const value: RoutinesCommandSuccess<{ readonly routine: DiscoveredRoutineRecord }> = {
+        ok: true,
+        kind: 'agent.routines.import_discovered.preview',
+        data: { routine: discovered },
+      };
+      return {
+        output: jsonOrText(runtime, value, [
+          'Agent routine import preview',
+          `  name: ${discovered.name}`,
+          `  origin: ${discovered.origin}`,
+          `  path: ${discovered.path}`,
+          `  description: ${discovered.description || '(none)'}`,
+          `  steps characters: ${discovered.steps.length}`,
+          '  next: rerun with --yes to import into the Agent-local routine registry',
+        ].join('\n')),
+        exitCode: 0,
+      };
+    }
+    const routine = registry.create({
+      name: discovered.name,
+      description: discovered.description || `Imported routine from ${discovered.origin} markdown file.`,
+      steps: discovered.steps,
+      tags: discoveredRoutineFrontmatterList(discovered, 'tags'),
+      triggers: discoveredRoutineFrontmatterList(discovered, 'triggers'),
+      enabled: parsed.enabled,
+      source: 'imported',
+      provenance: `discovered:${discovered.origin}:${discovered.path}`,
+    });
+    const value: RoutinesCommandSuccess<AgentRoutineRecord> = {
+      ok: true,
+      kind: 'agent.routines.import_discovered',
+      data: routine,
+    };
+    return {
+      output: jsonOrText(runtime, value, `Imported Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`),
+      exitCode: 0,
+    };
+  }
   if (normalized === 'show') {
     const id = rest[0];
     if (!id) return { output: 'Usage: goodvibes-agent routines show <id>', exitCode: 2 };
@@ -241,7 +396,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
+    output: 'Usage: goodvibes-agent routines [list|enabled|discover|import-discovered <name> --yes|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
     exitCode: 2,
   };
 }