Goal Tracking

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

client = DakeraClient(base_url="http://localhost:3000", 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="semantic",
        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 goals, still above the 0.7 recall threshold
        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 active goals with their latest progress and urgency."""
    response = client.recall(
        agent_id=agent_id,
        query="active goals objectives priorities deadlines current tasks",
        top_k=15,
        min_importance=0.70
    )

    records = [m.metadata or {} for m in response.memories]
    # A goal is closed once any memory with its goal_id records completed or abandoned
    closed = {r.get("goal_id") for r in records if r.get("status") in ("completed", "abandoned")}
    # The latest PROGRESS UPDATE per goal_id carries the current progress
    progress = {}
    for r in sorted((r for r in records if "progress_pct" in r and "updated_at" in r), key=lambda r: r["updated_at"]):
        progress[r["goal_id"]] = r["progress_pct"]

    goals = []
    today = date.today()
    for meta in records:
        if meta.get("status") != "active" or meta.get("goal_id") in closed:
            continue

        goal = {
            "goal_id": meta.get("goal_id"),
            "priority": meta.get("priority", "medium"),
            "progress_pct": progress.get(meta.get("goal_id"), 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 "\n".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:3000', 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,
    memory_type: 'semantic',
    tags: ['type:goal', 'status:active', `priority:${opts.priority ?? 'medium'}`, `goal:${goalId}`],
    metadata: {
      goal_id: goalId,
      parent_goal_id: opts.parentGoalId ?? null,
      status: 'active',
      priority: opts.priority ?? 'medium',
      deadline: opts.deadline ?? null,
      progress_pct: 0,
    },
  });

  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,
    memory_type: 'episodic',
    tags: ['type:goal-progress', `goal:${goalId}`],
    metadata: { goal_id: goalId, progress_pct: progressPct, updated_at: new Date().toISOString() },
  });
}

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

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

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

  const records = memories.map(m => (m.metadata ?? {}) as Record<string, any>);
  // Closed once any memory with the goal_id records completed or abandoned
  const closed = new Set(records.filter(r => r.status === 'completed' || r.status === 'abandoned').map(r => r.goal_id));
  // Latest progress update per goal_id
  const progress = new Map<string, number>();
  records
    .filter(r => r.progress_pct !== undefined && r.updated_at)
    .sort((a, b) => String(a.updated_at).localeCompare(String(b.updated_at)))
    .forEach(r => progress.set(r.goal_id, r.progress_pct));

  const today = new Date();
  return records
    .filter(r => r.status === 'active' && !closed.has(r.goal_id))
    .map(r => {
      const daysRemaining = r.deadline
        ? Math.ceil((new Date(r.deadline).getTime() - today.getTime()) / 86_400_000)
        : undefined;
      return {
        goalId: r.goal_id as string,
        priority: (r.priority as Priority) ?? 'medium',
        progressPct: progress.get(r.goal_id) ?? r.progress_pct ?? 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_client::{DakeraClient, MemoryType, RecallRequest, StoreMemoryRequest};

let client = DakeraClient::builder("http://localhost:3000")
    .api_key("dk-...")
    .build()?;

// Create a goal (status and goal_id travel as tags)
client.store_memory(
    StoreMemoryRequest::new(
        "productivity-agent-user-1",
        "GOAL: Launch SaaS product to 1000 paying customers. Deadline: 2024-09-30. Priority: critical.",
    )
    .with_type(MemoryType::Semantic)
    .with_importance(0.93)
    .with_tags(vec![
        "type:goal".into(),
        "status:active".into(),
        "priority:critical".into(),
        "goal:q3-product-launch".into(),
    ]),
).await?;

// Recall goals at session start
let goals = client.recall(
    RecallRequest::new("productivity-agent-user-1", "active goals objectives priorities deadlines")
        .with_top_k(15)
        .with_min_importance(0.7),
).await?;

for goal in &goals.memories {
    if goal.content.starts_with("GOAL:") || goal.content.starts_with("SUB-GOAL:") {
        println!("Goal: {} (score {:.2})", goal.content, goal.score);
    }
}

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: "http://localhost:3000",
    APIKey:  "dk-...",
})
ctx := context.Background()

// Create a goal (status and goal_id travel as tags)
importance := float32(0.93)
_, err := client.StoreMemory(ctx, "productivity-agent-user-1", dakera.StoreMemoryRequest{
    Content:    "GOAL: Launch SaaS product to 1000 paying customers. Deadline: 2024-09-30. Priority: critical.",
    MemoryType: "semantic",
    Importance: &importance,
    Tags:       []string{"type:goal", "status:active", "priority:critical", "goal:q3-product-launch"},
})

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

// Build proactive context from the goal memories
for _, mem := range goals.Memories {
    if strings.HasPrefix(mem.Content, "GOAL:") || strings.HasPrefix(mem.Content, "SUB-GOAL:") {
        fmt.Printf("Goal: %s (score %.2f)\n", mem.Content, mem.Score)
    }
}