log

Instructions

Implementation Reference

• src/tools/index.ts:92-117 (registration)

  Registration of the 'log' tool definition in getToolDefinitions(), including name, description, and input schema.

  {
    name: "log",
    description: "Create or update today's daily log file. Optionally add notes to the log.",
    inputSchema: {
      type: "object",
      properties: {
        notes: { 
          type: "string"
        },
        tags: { 
          type: "array",
          items: { type: "string" },
          description: `${TAG_VALIDATION_DESCRIPTION}
  
            Analyze the note's content and identify key themes, concepts, and categories that connect it to other notes.
            Consider:
            - Core topics and themes present in the note
            - Broader domains or areas of knowledge
            - Types of information (decisions, ideas, research, etc.)
            - Projects or contexts that might want to reference this later
            Do not force tags - only add ones that naturally emerge from the content and would help build meaningful connections between notes.`
        }
      },
      required: ["notes", "tags"]
    }
  },

• src/tools/index.ts:55-58 (schema)

  TypeScript interface defining the input arguments for the 'log' tool.

  interface LogArgs {
    notes: string;
    tags?: string[];
  }

• src/tools/index.ts:226-271 (handler)

  The handler function for the 'log' tool within handleToolCall, which instantiates LogNote, adds tags if provided, appends the notes entry, and returns success or error.

  case "log": {
    try {
      const logArgs = args as LogArgs;
      
      // Create LogNote without tags first
      const logNote = new LogNote(notesPath);
      
      await logNote.load();
      
      try {
        // Add tags separately to handle validation errors
        if (logArgs.tags && logArgs.tags.length > 0) {
          logNote.addTags(logArgs.tags);
        }
        
        const result = await logNote.appendEntry(logArgs.notes);
        
        if (!result.success) {
          return {
            content: [{ type: "text", text: `Error creating log: ${result.error}` }],
            isError: true,
          };
        }
        
        return {
          content: [{ 
            type: "text", 
            text: `I've added your note to today's log at ${result.path}.`
          }],
        };
      } catch (tagError) {
        // Specific handling for tag validation errors
        const errorMessage = tagError instanceof Error ? tagError.message : String(tagError);
        return {
          content: [{ type: "text", text: errorMessage }],
          isError: true,
        };
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [{ type: "text", text: `Error in log command: ${errorMessage}` }],
        isError: true,
      };
    }
  }

• src/notes/LogNote.ts:10-80 (helper)

  LogNote class, extending Note, handles creation, loading, and appending timestamped entries to the daily log file. Used by the 'log' tool handler.

  export class LogNote extends Note {
    template: string;
  
    constructor(notesBasePath: string, options: LogNoteOptions = {}) {
      const date = options.date || new Date();
      const dateInfo = {
        dayOfWeek: format(date, 'EEEE'),
        fullDate: format(date, 'MMMM d, yyyy'),
        isoDate: format(date, 'yyyy-MM-dd'),
        time: format(date, 'h:mm a')
      };
      
      // Log notes always go in the Log directory with date-based filename
      const relativePath = path.join('Log', `${dateInfo.isoDate}.md`);
      
      super(notesBasePath, relativePath, { 
        ...options, 
        date 
      });
      
      this.template = `# ${this.dateInfo.dayOfWeek}, ${this.dateInfo.fullDate}\n\n`;
    }
    
    addEntry(entry: string): LogNote {
      // If note doesn't exist yet, initialize with template
      if (!this.exists && !this.content && this.template) {
        this.content = this.template;
      }
      
      // Generate a fresh timestamp for this entry
      const currentTime = format(new Date(), 'h:mm a');
      
      // Add entry with fresh timestamp
      this.content += `\n### [${currentTime}]\n${entry}`;
      return this;
    }
    
    async appendEntry(entry: string) {
      // Load existing content if available
      if (!this.exists) {
        await this.load();
        
        // If still no content, load template
        if (!this.template) {
          await this.loadTemplate();
        }
        
        if (!this.content && this.template) {
          this.content = this.template;
        }
      }
      
      // Add the entry
      this.addEntry(entry);
      
      // Save the updated note
      return await this.save();
    }
  
    // This method is referenced but not implemented in the original JS file
    // Adding it here for completeness
    async loadTemplate(): Promise<void> {
      try {
        // Implementation would depend on how templates are loaded
        // For now, we'll just use the default template
        this.template = `# ${this.dateInfo.dayOfWeek}, ${this.dateInfo.fullDate}\n\n`;
      } catch (error) {
        console.error("Error loading template:", error);
      }
    }
  }