DEV Community: Cris Mihalache

Using Chat GPT To Generate Datasets 🤖

Cris Mihalache — Wed, 21 Feb 2024 22:11:15 +0000

Recently I used Chat GPT to generate mock data in JSON format.

This is extremely powerful, as you can describe what real data looks like in your prompt, and Chat GPT will generate data with realistic content in fields like descriptions, titles, tags, etc.

This is a sample of the data Chat GPT generated:

  {
    "id": 3,
    "description": "Implementing OAuth2 for user authentication",
    "tags": [
      "@feature",
      "@security"
    ],
    "start": "2024-02-22T03:11:03",
    "end": "2024-02-22T06:36:18"
  }

Notice how the description, tags, and duration are all realistic.

Example

To build the documentation website for track-time-cli, I needed a database with mock data to have realistic command output in the documentation content.

To get Chat GPT to generate them for me, I used the following prompt:

Generate 5 time sheet entries with realistic software development tasks as descriptions. Use the following schema:

        {
          "id": 1,
          "description": "writing documentation",
          "tags": [
            "@feature",
            "@docs"
          ],
          "start": "2024-02-21T18:26:45",
          "end": "2024-02-21T19:33:08"
        }

The entries should be sequential in time, of varying durations (between 5 minutes and 5 hours), and have realistic descriptions that fit the software development time sheet theme.

The output should be in JSON, an array of time sheet entries conforming to the provided schema example.

Note that I specified the number of entries (5) and the type of activity (realistic software development tasks) that should be mentioned in the description.

I defined the output schema by providing an example of a correctly formatted time sheet entry. I also specified that they should be sequential in time and have realistic durations as would be expected for the defined type of activity.

Result

This was the output:

[
  {
    "id": 1,
    "description": "Refactoring user interface code",
    "tags": [
      "@feature",
      "@frontend"
    ],
    "start": "2024-02-21T18:26:45",
    "end": "2024-02-21T22:39:32"
  },
  {
    "id": 2,
    "description": "Optimizing database queries for report generation",
    "tags": [
      "@performance",
      "@database"
    ],
    "start": "2024-02-21T22:39:32",
    "end": "2024-02-22T03:11:03"
  },
  {
    "id": 3,
    "description": "Implementing OAuth2 for user authentication",
    "tags": [
      "@feature",
      "@security"
    ],
    "start": "2024-02-22T03:11:03",
    "end": "2024-02-22T06:36:18"
  },
  {
    "id": 4,
    "description": "Weekly team sync-up meeting",
    "tags": [
      "@meeting",
      "@communication"
    ],
    "start": "2024-02-22T06:36:18",
    "end": "2024-02-22T10:16:24"
  },
  {
    "id": 5,
    "description": "Adding localization support for new languages",
    "tags": [
      "@feature",
      "@i18n"
    ],
    "start": "2024-02-22T10:16:24",
    "end": "2024-02-22T11:50:10"
  }
]

After running this prompt a few times to generate 16 entries, I placed them all in an array within a mock JSON database. The output of running track-time-cli's list command was the following:

 23:50 ▶ 97% ▶ xia ▶ f3rno64 ▶ .track-time-cli ▶  main ▶ ✎ ▶ 2? ▶ $ ▶ tt l
* Showing sheets since 2/21/2024, 12:00:00 AM [yesterday]

- Sheet main (16 entries) [1:10:19:16]
    (1)   [9:28:26]  yesterday       ->  14 hours ago    Writing API documentation                           @feature @docs
    (2)   [16:51]    14 hours ago    ->  14 hours ago    Implementing user authentication module             @feature @backend
    (3)   [50:01]    14 hours ago    ->  13 hours ago    Designing database schema for new features          @design @database
    (4)   [2:04:11]  13 hours ago    ->  11 hours ago    Improving responsive design for mobile devices      @feature @frontend
    (5)   [2:29:48]  11 hours ago    ->  9 hours ago     Conducting user experience research                 @research @ux
    (6)   [1:42:30]  9 hours ago     ->  7 hours ago     Implementing caching for improved performance       @performance @backend
    (7)   [9:08]     7 hours ago     ->  7 hours ago     Weekly team retrospective meeting                   @meeting @team
    (8)   [39:52]    7 hours ago     ->  6 hours ago     Refining search algorithm                           @algorithm @backend
    (9)   [2:13:23]  6 hours ago     ->  4 hours ago     Reviewing and merging pull requests                 @review @version-control
    (10)  [1:08:12]  4 hours ago     ->  3 hours ago     Developing new feature for customer analytics       @feature @analytics
    (11)  [2:27:32]  3 hours ago     ->  21 minutes ago  Solving compatibility issues in cross-platform app  @bugfix @mobile
    (12)  [3:14:14]  21 minutes ago  ->  in 3 hours      Organizing backlog and prioritizing tasks           @planning @management
    (13)  [3:07:36]  in 3 hours      ->  in 6 hours      Upgrading server infrastructure                     @maintenance @devops
    (14)  [1:41:17]  in 6 hours      ->  in 8 hours      Creating automated tests for new API endpoints      @testing @automation
    (15)  [2:02:29]  in 8 hours      ->  in 10 hours     Troubleshooting server downtime issues              @maintenance @devops
    (16)  [43:46]    in 10 hours     ->  in 10 hours     Designing user interface for the upcoming module    @design @frontend

* 0 Sheets not shown. use --all to show

Conclusions

Clearly Chat GPT is a great tool for generating realistic datasets.

Try it out the next time you need some mock data with realistic textual content! 🚀

time-speak: A Node.JS Library For Parsing Dates and Durations 🚀🕒

Cris Mihalache — Mon, 15 Jan 2024 17:53:51 +0000

Get time-speak here on npm

While working on track-time-cli, I encountered the need for a library to parse dates and intervals, so natural language could be used to specify time sheet entry start & end dates. For example, tt in --at 'three hours ago' some task

I went ahead and wrote a tiny library for this, time-speak. It is nearly dependency-free, with just one requirement of numbers-from-words, another zero-dependency library of mine for parsing numbers from words (i.e. parse('twenty three')).

Usage

To use, install it with npm i --save time-speak and import the parse method with either import { parse } from 'time-speak' or import parse from 'time-speak', then just pass the parse method your input string.

Thanks to numbers-from-words, number words are supported in the input, so all of the following are valid inputs:

"2 days and three hours ago"
"in five weeks"
"3 minutes ago"
"24 hours"

Inputs specifying a date in the future (starting with "in") are parsed as such, while inputs ending in "ago" are parsed as dates in the past, relative to the present moment. Such inputs to parse return Date objects.

Inputs without the "in" prefix or "ago" suffix are parsed as durations, and the return value is the duration length in milliseconds, a number.

Here is an example taken from the docs:

import { parse } from 'time-speak'

const pastDate = parse('2 days and 4 hours ago')
const pastDateWithNumberWords = parse('two days and four hours ago')
const futureDate = parse('in 4 hours')
const durationMS = parse('6 months')

console.log({
  pastDateWithNumberWords,    // 2023-12-19T13:02:39.768Z
  pastDate,                   // 2023-12-19T13:02:39.768Z
  futureDate,                 // 2023-12-21T21:02:39.768Z
  durationMS                  // 15552000000
})

That's it! Go ahead and start hacking!

Links:

Github
NPM

A Powerful Node.JS CLI Time Tracker ⏱️🚀

Cris Mihalache — Sun, 24 Dec 2023 19:52:57 +0000

After using Ruby's timetrap (sadly no longer maintained) for many years, I realized there was no equivalent in the Node.JS ecosystem, so I decided to build one.

Introducing track-time-cli, a utility for keeping track of the time you spend on your projects and (eventually) viewing useful metrics and statistics on your performance.

It is a Node.JS CLI app written in TypeScript supporting natural language input for task start/end times (i.e., 1 hour ago or twelve minutes ago.)

Most commands offer arguments for altering the display of durations in natural language (i.e., 33:00 as 33 minutes) or times as relative (i.e., 12/24/2023, 6:51:39 PM as 26 minutes ago.)

Getting Started

Install it with npm i -g track-time-cli; the entry point/command is tt, and by default, when called with no arguments, it shows the currently active timesheet entry.

All data is stored in ~/.track-time-cli/db.json, a folder that you can turn into a git repository for backing up your data as the number of entries grows.

Run tt --help to view the list of supported commands:



track-time-cli now

Display all active time sheet entries

Commands:
  track-time-cli in <description..>    Check in to a time sheet     [aliases: i]
  track-time-cli now                   Display all active time sheet entries
                                                                       [default]
  track-time-cli out                   Check out of the currently active time
                                       sheet entry                  [aliases: o]
  track-time-cli week [sheets..]       Display a summary of activity for the
                                       past week                    [aliases: w]
  track-time-cli list [sheets..]       List all time sheet entries  [aliases: l]
  track-time-cli edit [description..]  View, modify, or delete a time sheet
                                       entry                        [aliases: e]
  track-time-cli today [sheets..]      Display a summary of activity for today
                                                                    [aliases: t]
  track-time-cli sheet [name]          Switch to or delete a sheet by name
                                                                    [aliases: s]
  track-time-cli sheets                List all sheets             [aliases: ss]
  track-time-cli resume                Resume the last active entry [aliases: r]
  track-time-cli yesterday [sheets..]  Display a summary of activity for
                                       yesterday                    [aliases: y]
  track-time-cli breakdown [sheets..]  Display total durations per day for one
                                       or more sheets               [aliases: b]

Options:
      --version   Show version number                                  [boolean]
  -h, --humanize  Print the total duration in human-readable format    [boolean]
      --help      Show help                                            [boolean]

Examples:
  tt in --at "20 minutes ago" fixing a bug  Check in at a custom time
  tt out --at "5 minutes ago"               Check out at a custom time
  tt list --today --all                     View all entries from today
  tt b                                      Show a breakdown of your activity
  tt today --all                            View activity for the current day

A Note on Command Aliases

Almost all commands have short aliases, which I will use exclusively in this post. For example, tt yesterday is the same as tt y. Check the output of tt --help for information on available aliases.

Timesheets 📚

A task in track-time-cli is known as a timesheet entry and belongs to a timesheet. Timesheets can represent any group or category of tasks but are primarily meant to represent individual projects.

To view the list of timesheets, run tt sheets or the shorter tt ss.

Managing Timesheets

To create a new timesheet, or switch to an existing one, run tt s [name]. Running tt s with no name will display the currently active timesheet.

When the DB is initialized, a timesheet named main is created and set as active by default.

To delete a timesheet, run tt s --delete [timesheet name].

Tracking Tasks ⏱️

To start, or check in to a timesheet entry, run tt in [description]. If you started working earlier and forgot to check in, you can do so retroactively with the --at argument, i.e., tt in --at '10 minutes ago' developing feature X would create a timesheet entry that started 10 minutes ago with a description of developing feature X.

If you want to start a new entry with the same description as the previous one, tt resume (or tt r) exists, which will check in with the same description as the most recently active entry on the sheet.

Similarly, to end or check out of a task, run tt out optionally, providing the --at argument (i.e., tt out --at '5 minutes ago) if you stopped working and forgot to check out of your time sheet.

All of the following are valid in/out time inputs:

'19 minutes ago'
'forty five minutes ago'
'1 hour and 20 minutes ago'
'1 day, three hours, and 2 minutes ago'

Viewing Tasks 📃

To view historical and active tasks, there is the list command, tt l, which will print out a list of tasks. It is fairly powerful; here is the output of tt l --help:



track-time-cli list [sheets..]

List all time sheet entries

Options:
      --version          Show version number                           [boolean]
  -r, --ago, --relative  Print dates as relative time (e.g. 5 minutes ago)
                                                                       [boolean]
  -h, --humanize         Print the total duration in human-readable format
                                                                       [boolean]
  -s, --since            Only list entries since the specified date     [string]
  -t, --today            Show results for today                        [boolean]
      --all-sheets       Show results for all sheets                   [boolean]
  -a, --all              Show all sheet entries                        [boolean]
  -y, --yesterday        Show results from yesterday                   [boolean]
  -c, --concise          Exclude start and end dates from output, showing
                         duration only                                 [boolean]
      --help             Show help                                     [boolean]
      --sheets           Show results for the specified sheets
  [array] [choices: "track-time-cli", "cst", "personal", "time-speak", "coding",
    "gaming", "blog", "node-ts-lib-template", "track-time-cli-ui", "to-numbers"]

It defaults to showing data from the last 24 hours, a setting which can be modified with the --since argument. For example, for my own track-time-cli timesheet, running tt l track-time-cli --since '7 days ago' results in the following output:

The list command supports many options for formatting the output, such as displaying durations in natural language or times/dates as relative. For example, the output of tt l --all-sheets --since '2 days ago' -r -h for me is:

Convenience Commands

There are three commands to list specific spans of time, which I think one would often use:

tt today (tt t)
tt yesterday (tt y)
tt week (tt w)

Their output and arguments are similar to tt l; here is the output of tt week -t -h for me:

Future Plans 🚀

A breakdown command currently shows the total time spent per hour of the day or per weekday for entries sourced from multiple time sheets.

This is WIP and will be improved in the future; the plan is to use the stored data to tell when you are most productive and view other useful derivative data.

I haven't covered every feature in this post, so feel free to check it out yourself!

For more information, check out the README.md and the GitHub repo itself.

Any feedback, comments, or suggestions would be more than welcome!

Happy holidays, everyone! 🎅🎄

A Tiny JS Library For Parsing Numbers From Words

Cris Mihalache — Sat, 23 Dec 2023 00:47:46 +0000

After encountering the need to parse numbers written out as strings with multiple words for a project (i.e., "twenty-two days ago" as opposed to "22 days ago"), I went ahead and developed a tiny, zero-dependency library that does exactly that.

I've christened it numbers-from-words, and will be using it in my time tracker project.

Here is a short snippet showing a few input types:

import { parse } from 'numbers-from-words'

const valueA = parse('twenty')
const valueB = parse('one hundred and twenty three')
const valueC = parse('one thousand, two hundred and thirty four')

console.log({
    valueA,  // 20
    valueB,  // 123
    valueC   // 1234
})

Parsing is relatively simple, and the logic can be found here. In short, it supports any valid written representation of a number, which is usually a quantity followed by a magnitude (i.e. "two months" or "twenty five years").

Commas dividing the string for more complex written numbers are also supported, such as "twenty-five, one hundred, and three thousand" (parsed to 3125).

It categorizes number words into Numbers, Teens, Multiples, and Magnitudes. These are the available (and therefore supported) values:

export enum Numbers {
  Zero = 0,
  One = 1,
  Two = 2,
  Three = 3,
  Four = 4,
  Five = 5,
  Six = 6,
  Seven = 7,
  Eight = 8,
  Nine = 9
}

export enum Teens {
  Ten = 10,
  Eleven = 11,
  Twelve = 12,
  Thirteen = 13,
  Fourteen = 14,
  Fifteen = 15,
  Sixteen = 16,
  Seventeen = 17,
  Eighteen = 18,
  Nineteen = 19
}

export enum Multiples {
  Twenty = 20,
  Thirty = 30,
  Forty = 40,
  Fifty = 50,
  Sixty = 60,
  Seventy = 70,
  Eighty = 80,
  Ninety = 90
}

export enum Magnitudes {
  Hundred = 100,
  Thousand = 1000,
  Million = 1000000,
  Billion = 1000000000,
  Trillion = 1000000000000,
  Quadrillion = 1000000000000000
}

For more information, check out the README.md and the GitHub repo itself.

A Modern Node.JS TypeScript Lib Template

Cris Mihalache — Thu, 21 Dec 2023 22:21:22 +0000

Today, I put together a template repo for new Node.JS projects written in TypeScript that uses a standard set of utilities such as TypeDoc, mocha, nyc, ESLint, and more.

It provides a strict configuration and is fairly opinionated, but I think it results in less time spent writing boilerplate code and serves as a clean base to build upon.

I wrote a blog post about it, and would love any feedback, comments, or suggestions.

The repo is here: f3rno64/node-ts-lib-template