Goal Tracking

from dakera import DakeraClient
from datetime import datetime, date
from typing import Optional
import re

client = DakeraClient(base_url="http://localhost:3300", api_key="dk-...")

def slugify(text: str) -> str:
    return re.sub(r'[^a-z0-9]+', '-', text.lower()).strip('-')[:40]

def create_goal(
    agent_id: str,
    objective: str,
    priority: str = "medium",
    deadline: Optional[str] = None,  # ISO date string "YYYY-MM-DD"
    parent_goal_id: Optional[str] = None
) -> str:
    """Store a new goal and return its goal_id."""
    goal_id = slugify(objective)
    is_sub_goal = parent_goal_id is not None
    prefix = "SUB-GOAL" if is_sub_goal else "GOAL"

    deadline_note = f" Deadline: {deadline}." if deadline else ""
    parent_note = f" Part of goal: {parent_goal_id}." if is_sub_goal else ""

    client.store_memory(
        agent_id=agent_id,
        content=f"{prefix}: {objective}.{deadline_note}{parent_note}",
        importance=0.87 if is_sub_goal else 0.93,
        memory_type="working",
        tags=["type:goal", "status:active", f"priority:{priority}", f"goal:{goal_id}"],
        metadata={
            "goal_id": goal_id,
            "parent_goal_id": parent_goal_id,
            "status": "active",
            "priority": priority,
            "deadline": deadline,
            "progress_pct": 0,
            "created_at": datetime.utcnow().isoformat()
        }
    )
    return goal_id

def update_goal_progress(agent_id: str, goal_id: str, progress_pct: int, milestone_note: str) -> None:
    """Store a progress update for an existing goal."""
    client.store_memory(
        agent_id=agent_id,
        content=f"PROGRESS UPDATE [{goal_id}]: {progress_pct}% complete. {milestone_note}",
        importance=0.80,
        memory_type="episodic",
        tags=["type:goal-progress", f"goal:{goal_id}"],
        metadata={
            "goal_id": goal_id,
            "progress_pct": progress_pct,
            "milestone": milestone_note,
            "updated_at": datetime.utcnow().isoformat()
        }
    )

def complete_goal(agent_id: str, goal_id: str, outcome: str) -> None:
    """Mark a goal as completed (store new memory — do NOT delete the original)."""
    client.store_memory(
        agent_id=agent_id,
        content=f"GOAL COMPLETED [{goal_id}]: {outcome}",
        importance=0.82,  # Lower than active -- completed goals should not dominate recall
        memory_type="semantic",
        tags=["type:goal", "status:completed", f"goal:{goal_id}"],
        metadata={
            "goal_id": goal_id,
            "status": "completed",
            "completed_at": datetime.utcnow().isoformat(),
            "outcome": outcome
        }
    )

def abandon_goal(agent_id: str, goal_id: str, reason: str) -> None:
    """Mark a goal as abandoned."""
    client.store_memory(
        agent_id=agent_id,
        content=f"GOAL ABANDONED [{goal_id}]: {reason}",
        importance=0.65,
        memory_type="semantic",
        tags=["type:goal", "status:abandoned", f"goal:{goal_id}"],
        metadata={"goal_id": goal_id, "status": "abandoned", "reason": reason}
    )

def get_active_goals(agent_id: str) -> list:
    """Recall all active goals with urgency annotations."""
    results = client.recall(
        agent_id=agent_id,
        query="active goals objectives priorities deadlines current tasks",
        top_k=15,
        min_importance=0.70
    )

    goals = []
    today = date.today()

    for mem in results.get("memories", []):
        meta = mem.get("metadata", {})
        if meta.get("status") != "active":
            continue

        goal = {
            "goal_id": meta.get("goal_id"),
            "content": mem["content"],
            "priority": meta.get("priority", "medium"),
            "progress_pct": meta.get("progress_pct", 0),
            "days_remaining": None,
            "urgent": False
        }

        if meta.get("deadline"):
            try:
                deadline = date.fromisoformat(meta["deadline"])
                days_remaining = (deadline - today).days
                goal["days_remaining"] = days_remaining
                goal["urgent"] = days_remaining <= 14
            except ValueError:
                pass

        goals.append(goal)

    # Sort: critical + urgent first
    return sorted(goals, key=lambda g: (
        0 if g["priority"] == "critical" else 1 if g["priority"] == "high" else 2,
        0 if g["urgent"] else 1
    ))

def build_goal_context_prompt(agent_id: str) -> str:
    """Generate system prompt context from active goals."""
    goals = get_active_goals(agent_id)
    if not goals:
        return "No active goals recorded for this user."

    lines = ["Active goals:"]
    for g in goals:
        urgency = " [URGENT]" if g["urgent"] else ""
        days = f" ({g['days_remaining']} days remaining)" if g["days_remaining"] is not None else ""
        progress = f" — {g['progress_pct']}% complete"
        lines.append(f"  - [{g['priority'].upper()}]{urgency} {g['goal_id']}{progress}{days}")

    return "
".join(lines)

# --- Example usage ---
agent = "productivity-agent-user-1"
goal_id = create_goal(agent, "Launch SaaS product to 1000 paying customers", "critical", "2024-09-30")
sub_goal = create_goal(agent, "Complete beta testing with 50 users", "high", "2024-08-31", goal_id)
update_goal_progress(agent, goal_id, 40, "MVP feature set complete, beta testing at 60%")
print(build_goal_context_prompt(agent))

import { DakeraClient } from '@dakera-ai/dakera';

const client = new DakeraClient({ baseUrl: 'http://localhost:3300', apiKey: 'dk-...' });

type GoalStatus = 'active' | 'completed' | 'abandoned' | 'paused';
type Priority = 'critical' | 'high' | 'medium' | 'low';

interface GoalOptions {
  priority?: Priority;
  deadline?: string;  // ISO date "YYYY-MM-DD"
  parentGoalId?: string;
}

function slugify(text: string): string {
  return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
}

async function createGoal(agentId: string, objective: string, opts: GoalOptions = {}): Promise<string> {
  const goalId = slugify(objective);
  const isSubGoal = !!opts.parentGoalId;
  const prefix = isSubGoal ? 'SUB-GOAL' : 'GOAL';
  const deadlineNote = opts.deadline ? ` Deadline: ${opts.deadline}.` : '';
  const parentNote = opts.parentGoalId ? ` Part of goal: ${opts.parentGoalId}.` : '';

  await client.storeMemory(agentId, {
    content: `${prefix}: ${objective}.${deadlineNote}${parentNote}`,
    importance: isSubGoal ? 0.87 : 0.93,
    memoryType: 'working',
    tags: ['type:goal', 'status:active', `priority:${opts.priority ?? 'medium'}`, `goal:${goalId}`],
  });

  return goalId;
}

async function updateGoalProgress(agentId: string, goalId: string, progressPct: number, milestoneNote: string): Promise<void> {
  await client.storeMemory(agentId, {
    content: `PROGRESS UPDATE [${goalId}]: ${progressPct}% complete. ${milestoneNote}`,
    importance: 0.80,
    memoryType: 'episodic',
    tags: ['type:goal-progress', `goal:${goalId}`],
  });
}

async function completeGoal(agentId: string, goalId: string, outcome: string): Promise<void> {
  await client.storeMemory(agentId, {
    content: `GOAL COMPLETED [${goalId}]: ${outcome}`,
    importance: 0.82,
    memoryType: 'semantic',
    tags: ['type:goal', 'status:completed', `goal:${goalId}`],
  });
}

interface ActiveGoal {
  goalId: string;
  priority: Priority;
  progressPct: number;
  daysRemaining?: number;
  urgent: boolean;
}

async function getActiveGoals(agentId: string): Promise<ActiveGoal[]> {
  const result = await client.recall(
    agentId,
    'active goals objectives priorities deadlines current tasks',
    { top_k: 15, min_importance: 0.7 }
  );

  const today = new Date();
  return result.memories
    .filter(m => m.metadata?.status === 'active')
    .map(m => {
      const meta = m.metadata ?? {};
      const deadline = meta.deadline as string | undefined;
      const daysRemaining = deadline
        ? Math.ceil((new Date(deadline).getTime() - today.getTime()) / 86_400_000)
        : undefined;
      return {
        goalId: meta.goal_id as string,
        priority: (meta.priority as Priority) ?? 'medium',
        progressPct: (meta.progress_pct as number) ?? 0,
        daysRemaining,
        urgent: daysRemaining !== undefined && daysRemaining <= 14,
      };
    })
    .sort((a, b) => {
      const priorityOrder: Record<Priority, number> = { critical: 0, high: 1, medium: 2, low: 3 };
      return priorityOrder[a.priority] - priorityOrder[b.priority];
    });
}

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};
use std::collections::HashMap;

let client = Client::new("http://localhost:3300", "dk-...");

// Create a goal
client.store_memory("productivity-agent-user-1", StoreMemoryRequest {
    content: "GOAL: Launch SaaS product to 1000 paying customers. Deadline: 2024-09-30. Priority: critical.".into(),
    importance: Some(0.93),
    memory_type: "working".into(),
    tags: vec![
        "type:goal".into(),
        "status:active".into(),
        "priority:critical".into(),
        "goal:q3-product-launch".into(),
    ],
    ..Default::default()
}).await?;

// Recall active goals at session start
let goals = client.recall("productivity-agent-user-1", RecallRequest {
    query: "active goals objectives priorities deadlines".into(),
    top_k: Some(15),
    min_importance: Some(0.70),
    ..Default::default()
}).await?;

// Filter to active goals and compute urgency
for goal in &goals.memories {
    if let Some(meta) = &goal.metadata {
        if meta.get("status").and_then(|v| v.as_str()) == Some("active") {
            let goal_id = meta.get("goal_id").and_then(|v| v.as_str()).unwrap_or("unknown");
            println!("Active goal: {}", goal_id);
        }
    }
}

client := dakera.NewClient("http://localhost:3300", "dk-...")
ctx := context.Background()

// Create a goal
client.StoreMemory(ctx, "productivity-agent-user-1", dakera.StoreMemoryRequest{
    Content:    "GOAL: Launch SaaS product to 1000 paying customers. Deadline: 2024-09-30. Priority: critical.",
    Importance: 0.93,
    MemoryType: "working",
    Tags:       []string{"type:goal", "status:active", "priority:critical", "goal:q3-product-launch"},
    Metadata: map[string]interface{}{
        "goal_id":      "q3-product-launch",
        "status":       "active",
        "priority":     "critical",
        "deadline":     "2024-09-30",
        "progress_pct": 0,
    },
})

// Recall active goals at session start
goals, _ := client.Recall(ctx, "productivity-agent-user-1", dakera.RecallRequest{
    Query:         "active goals objectives priorities deadlines",
    TopK:          15,
    MinImportance: 0.70,
})

// Build proactive context
today := time.Now()
for _, mem := range goals.Memories {
    if status, ok := mem.Metadata["status"].(string); ok && status == "active" {
        if deadline, ok := mem.Metadata["deadline"].(string); ok {
            d, _ := time.Parse("2006-01-02", deadline)
            daysRemaining := int(d.Sub(today).Hours() / 24)
            if daysRemaining <= 14 {
                fmt.Printf("[URGENT] Goal %s: %d days remaining
", mem.Metadata["goal_id"], daysRemaining)
            }
        }
    }
}